码迷,mamicode.com
首页 > 编程语言 > 详细

SSM-mybatis-spring容器 复杂和简化方法

时间:2018-04-28 21:02:38      阅读:159      评论:0      收藏:0      [点我收藏+]

标签:release   xmx   com   and   扫描   教师   永久   method   span   

回顾
-------------
    1、JVM
        runtime data area.
        a.method area
            方法区,永久区,metaspace , 共享
        b.heap
            堆区,共享
            heap    = young代 + old代理
            young    = 伊甸区 + 幸存区
            幸存区    = 幸存一区(from) + 幸存二区(to),内存碎片整理
            所有对象诞生于伊甸区。
            
            heap            //
            non-heap        //非堆 , metaspace
            off-heap        //离堆 , os - jvm
                            //ByteBuffer.allocateDirect(1024) ; cleaner
            -Xms            //堆初始值
            -Xmx            //堆最大值
            -Xmn            //年轻代大小
            -XX:NewSize
            -XX:MaxNewSize
            -XX:NewRatio        //年老代是年轻代的倍数
            -XX:SurvivorRatio    //伊甸区是单个幸存区的倍数
            -Xloggc:<file>        //
            
        c.java stack
            线程,StackFrame(method frame) , push | pop
            死递归 , 
            -Xss1m

        d.native method stack
        e.program couter register

        System.gc()
        没有任何指针能够直接或间接到达他。

        jvisualvm
        jconsole
        jmap


    2、ClassLoader
        类加载器,将类型映射到路径,加载对应字节码文件到内存的方法区。
        三级类加载机制,Bootstrap(核心类) -> ExtClassLoader(jre\ext\xxx.jar) -> AppClassLoader
        extends ClassLoader{
            findClass(){
                defineClass(byte[] .. ) ;
            }
        }

    2、mybatis
        sql映射,oop方式访问jdbc。


实现mybatis的一对多关联关系
---------------------------
    1、修改Customer.class,增加集合属性
        class Customer{
            ...
            private List<Order> orders = new ArrayList<Order>();
            //get/set
        }
    2、修改CustomerMapper.xml
        <?xml version="1.0" encoding="UTF-8" ?>
        <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
                "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
        <mapper namespace="customers">
            <insert id="insert">
              insert into customers(name, age) values(#{name} , #{age})
            </insert>

            <update id="update">
                update customers set name = #{name} , age = #{age} where id = #{id}
            </update>

            <delete id="deleteOne">
                delete from customers where id = #{id}
            </delete>

            <delete id="deleteAll">
                delete from customers
            </delete>

            <select id="selectOne" resultMap="rmCustomer">
                SELECT
                  c.id cid ,
                  c.name cname ,
                  c.age cage ,
                  o.id oid ,
                  o.orderno oorderno,
                  o.price oprice,
                  o.cid ocid
                FROM
                  customes c left outer join orders o
                ON
                  c.id = o.cid
                WHERE
                  c.id = #{id}
            </select>
            <select id="selectAll" resultType="_Customer">
                select * from customers
            </select>
            
            <resultMap id="rmCustomer" type="_Customer">
                <id column="cid" property="id" />
                <result column="cname" property="name" />
                <result column="cage" property="age" />
                <collection property="orders" ofType="_Order" column="ocid">
                    <id column="oid" property="id" />
                    <result column="oorderno" property="orderNo" />
                    <result column="oprice" property="price"/>
                </collection>
            </resultMap>
        </mapper>
    3、测试
        @Test
        public void testSelectOne() throws Exception {
            InputStream in = Resources.getResourceAsStream("mybatis-conf.xml") ;
            SqlSessionFactory f = new SqlSessionFactoryBuilder().build(in) ;
            SqlSession s = f.openSession() ;
            Customer c = s.selectOne("customers.selectOne" , 6) ;
            s.commit();
            s.close();
        }
    4、


自关联
-----------------
    树形图 : 
    全国
       |---河北省
                 |---保定
                 |---张家口
       |---河南省
               |--驻马店
               |---开封

    1.设计表
        create table areas(id int primary key auto_increment , areaname varchar(20) , pid int) ;

    2.创建Area类
        public class Area {
            private Integer id ;
            private String areaName ;
            private Area parentArea ;
            //get/set
        }
    3.映射文件
        <?xml version="1.0" encoding="UTF-8" ?>
        <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
                "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
        <mapper namespace="areas">
            <insert id="insert" useGeneratedKeys="true" keyProperty="id">
              insert into areas(areaname , pid) values(#{areaName} , #{parentArea.id})
            </insert>
        </mapper>
    
    4.配置文件
        <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration
                PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
                "http://mybatis.org/dtd/mybatis-3-config.dtd">
        <configuration>
            <properties>
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/big10"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </properties>

            <!-- 定义类型别名 -->
            <typeAliases>
                <typeAlias type="com.oldboy.mybatis.domain.Customer" alias="_Customer" />
                <typeAlias type="com.oldboy.mybatis.domain.Order" alias="_Order" />
                <typeAlias type="com.oldboy.mybatis.domain.Area" alias="_Area" />
            </typeAliases>

            <environments default="development">
                <environment id="development">
                    <transactionManager type="JDBC"/>
                    <dataSource type="POOLED">
                        <property name="driver" value="${driver}"/>
                        <property name="url" value="${url}"/>
                        <property name="username" value="${username}"/>
                        <property name="password" value="${password}"/>
                    </dataSource>
                </environment>
            </environments>
            <mappers>
                <mapper resource="CustomerMapper.xml"/>
                <mapper resource="OrderMapper.xml"/>
                <mapper resource="AreaMapper.xml"/>
            </mappers>
        </configuration>

    5.插入
        @Test
        public void testInsert() throws Exception {
            InputStream in = Resources.getResourceAsStream("mybatis-conf.xml") ;
            SqlSessionFactory f = new SqlSessionFactoryBuilder().build(in) ;
            SqlSession s = f.openSession() ;

            Area a1 = new Area("quanguo") ;
            Area a2 = new Area("hebeisheng" , a1) ;
            Area a3 = new Area("henansheng", a1) ;
            Area a4 = new Area("baoding",a2) ;
            Area a5 = new Area("zhangjiakou", a2) ;
            Area a6 = new Area("zhumadian", a3) ;
            Area a7 = new Area("kaifeng", a3) ;
            s.insert("areas.insert" , a1);
            s.insert("areas.insert" , a2);
            s.insert("areas.insert" , a3);
            s.insert("areas.insert" , a4);
            s.insert("areas.insert" , a5);
            s.insert("areas.insert" , a6);
            s.insert("areas.insert" , a7);
            s.commit();
            s.close();
        }

实现自关联查询
------------------
    1.查询自己和上级的信息
        select 
            s.id sid,
            s.areaname sname ,
            p.id pid ,
            p.areaname pname
        from 
            areas s left outer join areas p on s.pid = p.id  ;

    2.编写AreaMapper.xml
        <?xml version="1.0" encoding="UTF-8" ?>
        <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
                "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
        <mapper namespace="areas">
            <insert id="insert" useGeneratedKeys="true" keyProperty="id">
              insert into areas(areaname , pid) values(#{areaName} , #{parentArea.id})
            </insert>

            <select id="selectOne" resultMap="rmArea">
                select
                    s.id sid,
                    s.areaname sname ,
                    p.id pid ,
                    p.areaname pname
                from
                    areas s left outer join areas p on s.pid = p.id  
                WHERE
                    s.id = #{id}
            </select>
            <resultMap id="rmArea" type="_Area">
                <id column="sid" property="id" />
                <result column="sname" property="areaName" />
                <association property="parentArea" column="pid" javaType="_Area">
                    <id column="pid" property="id" />
                    <result column="pname" property="areaName"/>
                </association>
            </resultMap>
        </mapper>

    3.实现查询
        @Test
        public void testSelectOne() throws Exception {
            InputStream in = Resources.getResourceAsStream("mybatis-conf.xml") ;
            SqlSessionFactory f = new SqlSessionFactoryBuilder().build(in) ;
            SqlSession s = f.openSession() ;
            Area a1 = s.selectOne("areas.selectOne" , 2) ;

            s.commit();
            s.close();
        }

实现自关联的下级查询
----------------------
    1.增加Area的集合属性
        public class Area {
            ...
            //所辖区域集合
            private List<Area> children ;
            //get/set
        }
    2.映射文件
        <?xml version="1.0" encoding="UTF-8" ?>
        <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
                "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
        <mapper namespace="areas">
            <insert id="insert" useGeneratedKeys="true" keyProperty="id">
              insert into areas(areaname , pid) values(#{areaName} , #{parentArea.id})
            </insert>

            <select id="selectOne" resultMap="rmArea">
                select
                    p.id pid,
                    p.areaname pname ,
                    s.id sid ,
                    s.areaname sname ,
                    c.id cid ,
                    c.areaname cname
                from
                    areas s
                    left outer join areas p on s.pid = p.id
                    left outer join areas c on c.pid = s.id
                where
                    s.id = #{id}
            </select>
            <select id="selectAll" resultMap="rmArea">
                select
                    p.id pid,
                    p.areaname pname ,
                    s.id sid ,
                    s.areaname sname ,
                    c.id cid ,
                    c.areaname cname
                from
                    areas s
                    left outer join areas p on s.pid = p.id
                    left outer join areas c on c.pid = s.id
            </select>
            <resultMap id="rmArea" type="_Area">
                <id column="sid" property="id" />
                <result column="sname" property="areaName" />
                <association property="parentArea" column="pid" javaType="_Area">
                    <id column="pid" property="id" />
                    <result column="pname" property="areaName"/>
                </association>
                <collection property="children" column="sid" ofType="_Area">
                    <id column="cid" property="id"/>
                    <result column="cname" property="areaName"/>
                </collection>
            </resultMap>
        </mapper>
    3.
        public void testSelectOne() throws Exception {
            InputStream in = Resources.getResourceAsStream("mybatis-conf.xml") ;
            SqlSessionFactory f = new SqlSessionFactoryBuilder().build(in) ;
            SqlSession s = f.openSession() ;
            Area a1 = s.selectOne("areas.selectOne" , 2) ;

            s.commit();
            s.close();
        }

        @Test
        public void testSelectAll() throws Exception {
            InputStream in = Resources.getResourceAsStream("mybatis-conf.xml") ;
            SqlSessionFactory f = new SqlSessionFactoryBuilder().build(in) ;
            SqlSession s = f.openSession() ;
            List<Area> list = s.selectList("areas.selectAll" ) ;

            s.commit();
            s.close();
        }

 一对一关系
 ---------------
    1.创建husband,wife表。
        [主键关联]
        原理是一张表的主键和另外外一张表相一致。
        create table husbands(id int primary key auto_increment , hname varchar(20)) ;
        create table wifes(id int primary key auto_increment , wname varchar(20)) ;
        
        [外键关联]
        原理等同于多对一关联关系。

    2.创建类
        //丈夫类
        public class Husband {
            private Integer id ;
            private String hname ;
            //一对一关联关系
            private Wife wife ;
        }

        //妻子类
        public class Wife {
            private Integer id ;
            private String wname ;

            //双向一对一关联
            private Husband husband ;
            ...
        }
    3.映射文件
        [丈夫]
        <?xml version="1.0" encoding="UTF-8" ?>
        <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
                "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
        <mapper namespace="husbands">
            <insert id="insert" useGeneratedKeys="true" keyProperty="id">
              insert into husbands(hname) values(#{hname})
            </insert>

            <select id="selectOne" resultMap="rmHusband">
              select
                h.id hid ,
                h.hname hname ,
                w.wname wname
              FROM
                husbands h left outer join wifes w on h.id = w.id
              where
                h.id = #{id}
            </select>
            
            <resultMap id="rmHusband" type="_Husband">
                <id column="hid" property="id" />
                <result column="hname" property="hname" />
                <association property="wife" column="hid" javaType="_Wife">
                    <result column="wname" property="wname" />
                    <association property="husband" column="hid" javaType="_Husband">
                        <id column="hid" property="id"/>
                        <result column="hname" property="hname"/>
                    </association>
                </association>
            </resultMap>
        </mapper>

        [妻子]
        <?xml version="1.0" encoding="UTF-8" ?>
        <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
                "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
        <mapper namespace="wifes">
            <insert id="insert">
              insert into wifes(id , wname) values(#{husband.id} , #{wname})
            </insert>

        </mapper>
    4.配置文件
        <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration
                PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
                "http://mybatis.org/dtd/mybatis-3-config.dtd">
        <configuration>
            <properties>
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/big10"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </properties>

            <!-- 定义类型别名 -->
            <typeAliases>
                <typeAlias type="com.oldboy.mybatis.domain.Customer" alias="_Customer" />
                <typeAlias type="com.oldboy.mybatis.domain.Order" alias="_Order" />
                <typeAlias type="com.oldboy.mybatis.domain.Area" alias="_Area" />
                <typeAlias type="com.oldboy.mybatis.domain.Husband" alias="_Husband" />
                <typeAlias type="com.oldboy.mybatis.domain.Wife" alias="_Wife" />
            </typeAliases>

            <environments default="development">
                <environment id="development">
                    <transactionManager type="JDBC"/>
                    <dataSource type="POOLED">
                        <property name="driver" value="${driver}"/>
                        <property name="url" value="${url}"/>
                        <property name="username" value="${username}"/>
                        <property name="password" value="${password}"/>
                    </dataSource>
                </environment>
            </environments>
            <mappers>
                <mapper resource="CustomerMapper.xml"/>
                <mapper resource="OrderMapper.xml"/>
                <mapper resource="AreaMapper.xml"/>
                <mapper resource="HusbandMapper.xml"/>
                <mapper resource="WifeMapper.xml"/>
            </mappers>
        </configuration>

    5.测试
        @Test
        public void testInsert() throws Exception {
            InputStream in = Resources.getResourceAsStream("mybatis-conf.xml") ;
            SqlSessionFactory f = new SqlSessionFactoryBuilder().build(in) ;
            SqlSession s = f.openSession() ;
            Husband h = new Husband();
            h.setHname("huangxiaoming");

            Wife w = new Wife();
            w.setHusband(h);
            w.setWname("ab");

            s.insert("husbands.insert" , h) ;
            s.insert("wifes.insert" , w) ;
            s.commit();
            s.close();
        }

        @Test
        public void testSelectOne() throws Exception {
            InputStream in = Resources.getResourceAsStream("mybatis-conf.xml") ;
            SqlSessionFactory f = new SqlSessionFactoryBuilder().build(in) ;
            SqlSession s = f.openSession() ;
            Husband h = s.selectOne("husbands.selectOne",1);
            s.commit();
            s.close();
        }

多对多关系
-----------------
    1.创建表
        create table teas(id int primary key auto_increment , tno varchar(20)) ;
        create table stus(id int primary key auto_increment , sno varchar(20)) ;
        create table links(tid int , sid int) ;
    2.创建类
        [Tea]
        /**
         * 教师类
         */
        public class Tea {
            private Integer id ;
            private String tno ;

            private List<Stu> stus = new ArrayList<Stu>();

        }
        [Stu]
        /**
         * 学生类
         */
        public class Stu {
            private Integer id ;
            private String sno ;

            private List<Tea> teas = new ArrayList<Tea>();
        }

    3.映射文件
        [TeaMapper.xml]
        <?xml version="1.0" encoding="UTF-8" ?>
        <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
                "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
        <mapper namespace="teas">
            <insert id="insert" useGeneratedKeys="true" keyProperty="id">
              insert into teas(tno) values(#{tno})
            </insert>
            <insert id="insertLinks">
              <foreach collection="stus" item="s">
                insert into links(tid,sid) values(#{id} , #{s.id});
              </foreach>
            </insert>

            <select id="selectOne" resultMap="rmTea">
                select
                    t.id tid ,
                    t.tno tno ,
                    s.id sid ,
                    s.sno sno
                from
                    teas t
                    left outer join links l on l.tid = t.id
                    left outer join stus s  on s.id = l.sid
                where
                    t.id = #{id}
            </select>
            <resultMap id="rmTea" type="_Tea">
                <id column="tid" property="id"/>
                <result column="tno" property="tno" />
                <collection property="stus" ofType="_Stu" column="tid">
                    <id column="sid" property="id" />
                    <result column="sno" property="sno" />
                </collection>
            </resultMap>
        </mapper>

        [StuMapper.xml]
        <?xml version="1.0" encoding="UTF-8" ?>
        <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
                "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
        <mapper namespace="stus">
            <insert id="insert" useGeneratedKeys="true" keyProperty="id">
              insert into stus(sno) values(#{sno})
            </insert>
        </mapper>
    4.修改配置文件,添加执行多条语句支持
        <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration
                PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
                "http://mybatis.org/dtd/mybatis-3-config.dtd">
        <configuration>
            <properties>
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/big10?allowMultiQueries=true"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </properties>

            <!-- 定义类型别名 -->
            <typeAliases>
                <typeAlias type="com.oldboy.mybatis.domain.Customer" alias="_Customer" />
                <typeAlias type="com.oldboy.mybatis.domain.Order" alias="_Order" />
                <typeAlias type="com.oldboy.mybatis.domain.Area" alias="_Area" />
                <typeAlias type="com.oldboy.mybatis.domain.Husband" alias="_Husband" />
                <typeAlias type="com.oldboy.mybatis.domain.Wife" alias="_Wife" />
                <typeAlias type="com.oldboy.mybatis.domain.Tea" alias="_Tea" />
                <typeAlias type="com.oldboy.mybatis.domain.Stu" alias="_Stu" />
            </typeAliases>

            <environments default="development">
                <environment id="development">
                    <transactionManager type="JDBC"/>
                    <dataSource type="POOLED">
                        <property name="driver" value="${driver}"/>
                        <property name="url" value="${url}"/>
                        <property name="username" value="${username}"/>
                        <property name="password" value="${password}"/>
                    </dataSource>
                </environment>
            </environments>
            <mappers>
                <mapper resource="CustomerMapper.xml"/>
                <mapper resource="OrderMapper.xml"/>
                <mapper resource="AreaMapper.xml"/>
                <mapper resource="HusbandMapper.xml"/>
                <mapper resource="WifeMapper.xml"/>
                <mapper resource="TeaMapper.xml"/>
                <mapper resource="StuMapper.xml"/>
            </mappers>
        </configuration>

    5.测试类
        package com.oldboy.mybatis.test;

        import com.oldboy.mybatis.domain.Husband;
        import com.oldboy.mybatis.domain.Stu;
        import com.oldboy.mybatis.domain.Tea;
        import com.oldboy.mybatis.domain.Wife;
        import org.apache.ibatis.io.Resources;
        import org.apache.ibatis.session.SqlSession;
        import org.apache.ibatis.session.SqlSessionFactory;
        import org.apache.ibatis.session.SqlSessionFactoryBuilder;
        import org.junit.Test;

        import java.io.InputStream;

        /**
         * 测试多对多
         */
        public class TestMany2Many {
            @Test
            public void testInsert() throws Exception {
                InputStream in = Resources.getResourceAsStream("mybatis-conf.xml") ;
                SqlSessionFactory f = new SqlSessionFactoryBuilder().build(in) ;
                SqlSession s = f.openSession() ;

                Stu s1 = new Stu("s1") ;
                Stu s2 = new Stu("s2") ;
                Stu s3 = new Stu("s3") ;
                Stu s4 = new Stu("s4") ;

                Tea t1 = new Tea("t1");
                Tea t2 = new Tea("t2");

                t1.addStus(s1 ,s2 , s3);
                t2.addStus(s2 , s3 , s4);

                s.insert("stus.insert" , s1);
                s.insert("stus.insert" , s2);
                s.insert("stus.insert" , s3);
                s.insert("stus.insert" , s4);

                s.insert("teas.insert" , t1);
                s.insert("teas.insert" , t2);

                s.insert("teas.insertLinks" , t1);
                s.insert("teas.insertLinks" , t2);

                s.commit();
                s.close();
            }

            @Test
            public void testSelectOne() throws Exception {
                InputStream in = Resources.getResourceAsStream("mybatis-conf.xml") ;
                SqlSessionFactory f = new SqlSessionFactoryBuilder().build(in) ;
                SqlSession s = f.openSession() ;
                Tea t = s.selectOne("teas.selectOne" , 3) ;
                s.commit();
                s.close();
            }
        }

聚合函数查询
-----------------
    1.Mapper.xml
        <select id="selectCount" resultType="int">
            select count(*) from teas
        </select>
    2.查询
        int cnt = s.selectOne("teas.selectCount") ;
    
    3.多个聚合
        <select id="selectAgg" resultType="map">
            select max(price) max , min(price) min , avg(price) avg from orders
        </select>
    
    4.查询
        Map map = s.selectOne("orders.selectAgg");

    5.查询没有学生的老师数量
        1.查询不在links中出现的tid的数量。
            select count(distinct id) from teas where id not in (select distinct tid from links) ;
        
        2.连接查询
            select count(*) from teas t left outer join links l on l.tid = t.id where l.sid is null; 


Spring
-----------------
    业务层框架,管理bean,容器。 
    体验spring
    1、创建模块,添加maven依赖。 
        <?xml version="1.0" encoding="UTF-8"?>
        <project xmlns="http://maven.apache.org/POM/4.0.0"
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
            <modelVersion>4.0.0</modelVersion>

            <groupId>com.oldboy</groupId>
            <artifactId>myspring</artifactId>
            <version>1.0-SNAPSHOT</version>
            <dependencies>
                <dependency>
                    <groupId>junit</groupId>
                    <artifactId>junit</artifactId>
                    <version>4.11</version>
                </dependency>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-context</artifactId>
                    <version>4.3.5.RELEASE</version>
                </dependency>
            </dependencies>
        </project>
        
    2、创建接口和实现类
        [WelcomeService]
        public interface WelcomeService {
            public void sayHello() ;
        }

        [WelcomeServiceImpl]
        package com.oldboy.myspring.service;

        /**
         * 实现类
         */
        public class WelcomeServiceImpl implements WelcomeService{
            private String name ;

            public String getName() {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }

            public void sayHello() {
                System.out.println(name);
            }
        }

        [ByeService]
        public interface ByeService {
            public void sayBye();
        }

        [ByeServiceImpl]
        package com.oldboy.myspring.service;

        /**
         * Created by Administrator on 2018/4/28.
         */
        public class ByeServiceImpl implements ByeService{
            private String bye ;

            public String getBye() {
                return bye;
            }

            public void setBye(String bye) {
                this.bye = bye;
            }

            public void sayBye() {
                System.out.println(bye);
            }
        }



    3、创建配置文件
        [resource/beans.xml]
        <?xml version="1.0" encoding="UTF-8"?>
        <beans xmlns="http://www.springframework.org/schema/beans"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
            <!-- 配置bean -->
            <bean id="welService" class="com.oldboy.myspring.service.WelcomeServiceImpl">
                <property name="name" value="hello world" />
                <property name="bs" ref="byeService" />
            </bean>
            <!-- byeService -->
            <bean id="byeService" class="com.oldboy.myspring.service.ByeServiceImpl">
                <property name="bye" value="bye bye!!!" />
            </bean>
        </beans>

    4、App.java
        package com.oldboy.myspring;

        import com.oldboy.myspring.service.ByeService;
        import com.oldboy.myspring.service.WelcomeService;
        import org.springframework.context.ApplicationContext;
        import org.springframework.context.support.ClassPathXmlApplicationContext;

        /**
         */
        public class App {
            public static void main(String[] args) {
                //创建spring容器
                ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
                //从容器提取指定bean
                WelcomeService ws = (WelcomeService) ac.getBean("welService");
                ws.sayHello();

                //
                ByeService bs = (ByeService) ac.getBean("byeService");
                bs.sayBye();
            }
        }

spring
----------------
    思想两个:ioc和aop
    ioc : inverse of control,反转控制,获得对象的方式反转了。
    aop : aspect oriented program,面向方面编程。

    bean的范围:
    1.singleton
        单例,默认值。
    2.prototype
        原型,每次get都是创建新对象,等价于new操作。


    aop
    --------------
        系统级功能,aop对oop的增强。proxy
        1.引入新依赖
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjrt</artifactId>
                <version>1.6.1</version>
            </dependency>
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.8.10</version>
            </dependency>
            
        2.创建目录类和接口
            略
        3.创建前置通知
            public class MyMethodBeforeAdvice implements MethodBeforeAdvice{
                public void before(Method method, Object[] args, Object target) throws Throwable {
                    System.out.println("hello world");
                }
            }

        4.配置文件
            <?xml version="1.0" encoding="UTF-8"?>
            <beans xmlns="http://www.springframework.org/schema/beans"
                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
                <!-- 前置通知 -->
                <bean id="beforeAdvice" class="com.oldboy.myspring.aop.MyMethodBeforeAdvice" />

                <!-- 目标对象 -->
                <bean id="welserviceTarget" class="com.oldboy.myspring.aop.WelcomeServiceImpl">
                    <property name="name" value="tom" />
                </bean>

                <bean id="welService" class="org.springframework.aop.framework.ProxyFactoryBean">
                    <!--  代理接口集-->
                    <property name="proxyInterfaces">
                        <list>
                            <value>com.oldboy.myspring.aop.WelcomeService</value>
                        </list>
                    </property>
                    <!-- 拦截器名集 -->
                    <property name="interceptorNames">
                        <list>
                            <value>beforeAdvice</value>
                        </list>
                    </property>
                    <property name="target" ref="welserviceTarget" />
                </bean>
            </beans>
        5.测试
            package com.oldboy.myspring.aop;

            import org.springframework.context.ApplicationContext;
            import org.springframework.context.support.ClassPathXmlApplicationContext;

            /**
             */
            public class App {
                public static void main(String[] args) {
                    //创建spring容器
                    ApplicationContext ac = new ClassPathXmlApplicationContext("aop.xml");
                    WelcomeService ws = (WelcomeService) ac.getBean("welcomeService");
                    ws.sayHello();
                }
            }


后置通知
----------------
    1.创建通知
        /**
         * 后置通知
         */
        public class MyAfterReturningAdvice implements AfterReturningAdvice {
            public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
                System.out.println("after");
            }
        }
    
    2.配置aop.xml
        <?xml version="1.0" encoding="UTF-8"?>
        <beans xmlns="http://www.springframework.org/schema/beans"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
            <!-- 前置通知 -->
            <bean id="beforeAdvice" class="com.oldboy.myspring.aop.MyMethodBeforeAdvice" />
            <bean id="afterAdvice" class="com.oldboy.myspring.aop.MyAfterReturningAdvice" />

            <!-- 目标对象 -->
            <bean id="welserviceTarget" class="com.oldboy.myspring.aop.WelcomeServiceImpl">
                <property name="name" value="tom" />
            </bean>

            <!-- 代理对象 -->
            <bean id="welcomeService" class="org.springframework.aop.framework.ProxyFactoryBean">
                <!--  代理接口集-->
                <property name="proxyInterfaces">
                    <list>
                        <value>com.oldboy.myspring.aop.WelcomeService</value>
                    </list>
                </property>
                <!-- 拦截器名集 -->
                <property name="interceptorNames">
                    <list>
                        <value>beforeAdvice</value>
                        <value>afterAdvice</value>
                    </list>
                </property>
                <property name="target" ref="welserviceTarget" />
            </bean>
        </beans>
    
    3.测试
        略


环绕通知
------------------
    1.创建通知
        package com.oldboy.myspring.aop;

        import org.aopalliance.intercept.MethodInterceptor;
        import org.aopalliance.intercept.MethodInvocation;

        /**
         * 环绕通知
         */
        public class MyMethodInterceptor implements MethodInterceptor {
            public Object invoke(MethodInvocation invocation) throws Throwable {
                System.out.println("begin");
                //调用目标对象的方法
                Object ret = invocation.proceed() ;
                System.out.println("end");
                return ret;
            }
        }

    2.aop.xml
        <?xml version="1.0" encoding="UTF-8"?>
        <beans xmlns="http://www.springframework.org/schema/beans"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
            <!-- 前置通知 -->
            <bean id="beforeAdvice" class="com.oldboy.myspring.aop.MyMethodBeforeAdvice" />
            <!-- 后置通知 -->
            <bean id="afterAdvice" class="com.oldboy.myspring.aop.MyAfterReturningAdvice" />
            <!-- 环绕通知 -->
            <bean id="roundAdvice" class="com.oldboy.myspring.aop.MyMethodInterceptor" />

            <!-- 目标对象 -->
            <bean id="welserviceTarget" class="com.oldboy.myspring.aop.WelcomeServiceImpl">
                <property name="name" value="tom" />
            </bean>

            <!-- 代理对象 -->
            <bean id="welcomeService" class="org.springframework.aop.framework.ProxyFactoryBean">
                <!--  代理接口集-->
                <property name="proxyInterfaces">
                    <list>
                        <value>com.oldboy.myspring.aop.WelcomeService</value>
                    </list>
                </property>
                <!-- 拦截器名集 -->
                <property name="interceptorNames">
                    <list>
                        <value>beforeAdvice</value>
                        <value>afterAdvice</value>
                        <value>roundAdvice</value>
                    </list>
                </property>
                <property name="target" ref="welserviceTarget" />
            </bean>
        </beans>
    3.测试
        略

异常通知
-----------------
    1.创建通知
        package com.oldboy.myspring.aop;

        import org.springframework.aop.ThrowsAdvice;

        import java.lang.reflect.Method;

        /**
         * 异常通知
         */
        public class MyThrowAdvice implements ThrowsAdvice{
            public void afterThrowing(Method method, Object[] args, Object target, Exception ex){
                System.out.println("出事了!!");
                ex.printStackTrace();
            }
        }

    2.aop.xml
        <?xml version="1.0" encoding="UTF-8"?>
        <beans xmlns="http://www.springframework.org/schema/beans"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
            <!-- 前置通知 -->
            <bean id="beforeAdvice" class="com.oldboy.myspring.aop.MyMethodBeforeAdvice" />
            <!-- 后置通知 -->
            <bean id="afterAdvice" class="com.oldboy.myspring.aop.MyAfterReturningAdvice" />
            <!-- 环绕通知 -->
            <bean id="roundAdvice" class="com.oldboy.myspring.aop.MyMethodInterceptor" />
            <!-- 异常通知 -->
            <bean id="throwsAdvice" class="com.oldboy.myspring.aop.MyThrowAdvice" />

            <!-- 目标对象 -->
            <bean id="welserviceTarget" class="com.oldboy.myspring.aop.WelcomeServiceImpl">
                <property name="name" value="tom" />
            </bean>

            <!-- 代理对象 -->
            <bean id="welcomeService" class="org.springframework.aop.framework.ProxyFactoryBean">
                <!--  代理接口集-->
                <property name="proxyInterfaces">
                    <list>
                        <value>com.oldboy.myspring.aop.WelcomeService</value>
                    </list>
                </property>
                <!-- 拦截器名集 -->
                <property name="interceptorNames">
                    <list>
                        <value>beforeAdvice</value>
                        <value>afterAdvice</value>
                        <value>roundAdvice</value>
                        <value>throwsAdvice</value>
                    </list>
                </property>
                <property name="target" ref="welserviceTarget" />
            </bean>
        </beans>
    3.测试
        略


观众和演员的关系
-------------------
    1.观众类
        public class Audience {
            public void turnOffCellphone(){
                System.out.println("turnOffCellphone");
            }

            public void sitdown(){
                System.out.println("sitdown");
            }
            
            public void applaud(){
                System.out.println("applaud");
            }
            
            public void payOff(){
                System.out.println("payoff");
            }
            
            public void gohome(){
                System.out.println("gohome");
            }
        }

    2.创建演员类和接口
        [Performer]
        package com.oldboy.myspring.aop2;

        /**
         * Created by Administrator on 2018/4/28.
         */
        public interface Performer {
            public void show();
        }

        [Singer]
        package com.oldboy.myspring.aop2;

        /**
         * 歌手演员
         */
        public class Singer implements Performer{
            public void show() {
                System.out.println("啦啦啦~~~");
            }
        }

    3.aop.xml
        <?xml version="1.0" encoding="UTF-8"?>
        <beans xmlns="http://www.springframework.org/schema/beans"
               xmlns:aop="http://www.springframework.org/schema/aop"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans.xsd
               http://www.springframework.org/schema/aop
               http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

            <!-- 观众 -->
            <bean id="audience" class="com.oldboy.myspring.aop2.Audience"/>

            <!-- 歌手 -->
            <bean id="singer" class="com.oldboy.myspring.aop2.Singer"/>


            <aop:config>
                <!-- 将观众配置成方面 -->
                <aop:aspect id="audienceAspect" ref="audience">
                    <aop:pointcut id="audiencePointcut" expression="execution(* *..Performer.*(..))" />
                    <aop:before method="turnOffCellphone" pointcut-ref="audiencePointcut" />
                    <aop:before method="sitdown" pointcut-ref="audiencePointcut"/>
                    <aop:after-returning method="applaud" pointcut-ref="audiencePointcut"/>
                    <aop:after-throwing method="payOff" pointcut-ref="audiencePointcut"/>
                    <aop:after method="gohome" pointcut-ref="audiencePointcut"/>
                </aop:aspect>
            </aop:config>
        </beans>


使用环绕通知实现aop
---------------------
    1.观众类
        package com.oldboy.myspring.aop3;

        import org.aspectj.lang.ProceedingJoinPoint;

        /**
         * 观众bean
         */
        public class Audience {

            //环绕通知了.
            public Object watch(ProceedingJoinPoint pjp){
                try {
                    System.out.println("turnoffCellphone");

                    System.out.println("sitDown");
                    //开始你的表演
                    Object ret = pjp.proceed();
                    System.out.println("applaud");
                    return ret ;
                }
                catch (Throwable e) {
                    System.out.println("payOff");
                    e.printStackTrace();
                }
                finally {
                    System.out.println("gohome");
                }
                return null ;
            }
        }

    2.aop3.xml
        <?xml version="1.0" encoding="UTF-8"?>
        <beans xmlns="http://www.springframework.org/schema/beans"
               xmlns:aop="http://www.springframework.org/schema/aop"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans.xsd
               http://www.springframework.org/schema/aop
               http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

            <!-- 观众 -->
            <bean id="audience" class="com.oldboy.myspring.aop3.Audience"/>

            <!-- 歌手 -->
            <bean id="singer" class="com.oldboy.myspring.aop3.Singer"/>


            <aop:config>
                <!-- 将观众配置成方面 -->
                <aop:aspect id="audienceAspect" ref="audience">
                    <aop:around method="watch" pointcut="execution(* *..Performer.*(..))" />
                </aop:aspect>
            </aop:config>
        </beans>
    
    3.测试
        package com.oldboy.myspring.aop3;

        import org.springframework.context.ApplicationContext;
        import org.springframework.context.support.ClassPathXmlApplicationContext;

        /**
         */
        public class App {
            public static void main(String[] args) {
                //创建spring容器
                ApplicationContext ac = new ClassPathXmlApplicationContext("aop3.xml");
                Performer p = (Performer) ac.getBean("singer");
                p.show();
            }
        }

bean的简化配置
---------------------
    1.简介
        如果配置大量的bean,繁琐。

    2.在配置的类上增加注解。
        @Service            //服务
        @Controller            //控制器
        @Component            //组件
        @Repository            //仓库

        @Service("ws")
        @Scope("prototype")
        public class WelcomeServiceImpl implements WelcomeService{
            ...

            @Resource(name="byeService")
            private ByeService bs ;
        }


    3.配置文件beans2.xml
        <?xml version="1.0" encoding="UTF-8"?>
        <beans xmlns="http://www.springframework.org/schema/beans"
               xmlns:aop="http://www.springframework.org/schema/aop"
               xmlns:context="http://www.springframework.org/schema/context"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://www.springframework.org/schema/beans
                                http://www.springframework.org/schema/beans/spring-beans.xsd
                                http://www.springframework.org/schema/context
                                http://www.springframework.org/schema/context/spring-context-4.3.xsd
                                http://www.springframework.org/schema/aop
                                http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
            <!-- 组件扫描 -->
            <context:component-scan base-package="com.oldboy.myspring.service" />
        </beans>
        
    4.测试
        //创建spring容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans2.xml");
        WelcomeService ws = (WelcomeService) ac.getBean("welcomerService");
        ws.sayHello();

 

SSM-mybatis-spring容器 复杂和简化方法

标签:release   xmx   com   and   扫描   教师   永久   method   span   

原文地址:https://www.cnblogs.com/zyde/p/8969273.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!