Spring知识归整，速看速记！

Spring知识归整，速看速记！

一、Spring介绍

1、Spring是什么？
Spring是轻量级的JAVAEE应用开源框架
2、Spring的好处？
IOC：控制反转
AOP：面向切面 粘合剂：整合其他技术和框架

二、IOC

1、耦合
    耦合：对象之间的依赖关系(service依赖于dao)，耦合度越高维护的成本越高
    产生耦合的原因：硬编码
2、IOC
    控制：控制对象的创建
    IOC (Inverse of Control)即控制反转：正传是自己创建对象；反转是由工厂创建依赖对象
3、工厂模式的IOC解决程序耦合
    1.把dao和service配置到beans.properties
    2.读取beans.properties
    3.通过反射创建对象，并装到容器中
    4.在使用时，直接从容器中获得
4、spring的IOC解决程序耦合
    1.pom.xml
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.30</version>
        </dependency>
    2.log4j.properties
        复制mybatis
    3.applicationContext.xml
        <bean id="userDao" class="com.by.dao.UserDaoImpl" />
        <bean id="userService" class="com.by.dao.UserServiceImpl" />
    4、测试
        //带IOC容器的工厂
        ApplicationContext ac = new  ClassPathXmlApplicationContext("applicationContext.xml");
        ac.getBean("userService", UserService);

三、DI

1、什么是DI?
    DI（Dependency Injection）依赖注入：将依赖对象从容器中拿出来赋值给调用者
2、DI的方式
    1、构造方法注入
        public UserServiceImpl(UserDao userDao, String msg){
            this.userDao=userDao
            this.msg=msg
        }

        <bean id="userService" class="com.by.dao.UserServiceImpl" >
            <!--
                name="userDao"：构造方法的参数名称
                ref="userDao"：另一个bean标签的id
            -->
            <constructor-arg name="userDao" ref="userDao"></constructor-arg>
            <!--
                index="userDao"：构造方法的参数的索引位置
                value="我靠"：基本数据类型和String类型
            -->
            <constructor-arg index="0" value="我靠"></constructor-arg>
        </bean>
    2、set方法注入
        public setUserDao(UserDao userDao){
            this.userDao=userDao
        }

        public setMsg(String msg){
            this.msg=msg
        }

        <bean id="userService" class="com.by.dao.UserServiceImpl" >
            <property name="userDao" ref="userDao"></property>
            <property name="msg" value="我操"></property>
        </bean>
    3、自动注入
        //遍历map，并判断每个bean的类型，如果类型符合则赋值
        <bean id="userService" class="com.by.dao.UserServiceImpl" autowire="byType"></bean>

四、BeanFactory和ApplicationContext区别

ApplicationContext：子接口，加载配置文件时就创建对象
BeanFactory：顶级接口，使用对象时才创建

五、spring bean五种作用域(bean放哪了)

singleton：单例，ioc容器
prototype：多例，newInstance()
request：request域
session：session域
application：servletContext域

配置方式：<bean id="" class="" scope="prototype" />

单例和多例的使用场景？
    单例：service、dao、sqlSessionFactroy
    多例：connnect、sqlSession

六、spring bean的生命周期

1、案例：
    public class UserServiceImpl{

        private UserDao userDao;

        public UserServiceImpl(){
        }
        public setUserDao(){
        }
        public void init(){
        }
        public void destroy(){
        }
    }

    <bean id="" class="" scope="singleton"
              init-method="init" destroy-method="destroy" autowire="byType">
2、实验
    单例：
        [容器启动]---->构造方法(实例化)---->set方法(注入)---->init方法(初始化)---->[容器关闭]---->destroy方法(销毁bean)
    多例：
        [使用对象]---->构造方法(实例化)---->set方法(注入)---->init方法(初始化)---->[JVM垃圾回收]---->destroy方法(销毁bean)

七、spring基于注解的IOC

1、配置步骤
    1）pom.xml
        spring-context、slf4j-log4j12
    2.log4j.properties
        复制mybatis
    3）applicationContext.xml
        <context:component-scan base-package="com.by"></context:component-scan>
    4、ioc
        @Repository //<userDaoImpl, new UserDaoImpl()>
        public class UserDaoImpl{
        }
    5、DI
        public class UserServiceImpl{
            @Autowired
            private UserDao userDao;
        }

2、常用注解
    1）IOC
        @Controller：web
        @Service：service
        @Repository：dao
        @Component：三层架构之外
        @Scope("prototype")：指定bean的作用域范围，eg：singleton、prototype、request、session、application
    2）DI
        @Resource(name="")：按名称注入
        @Autowired：按类型
        @Value("${}")：注入基本类型和String类

八、AOP

1、为什么要使用AOP?
    有一万个service类，要求每个方法执行前打印日志，执行后打印日志
2、什么是AOP?
    AOP(Aspect Oriented Programming)面向切面编程：把程序中重复的代码抽取出来，使用动态代理的技术去执行，
    从而实现对方法的增强(不修改源代码对方法进行增强)
2、代理模式
    1）静态代理
        角色：
            公共接口：Star
            真实角色：RealStar(周杰伦.唱歌)
            代理角色：ProxyStar(宋吉吉.面谈.订机票.签合同.[调周杰伦唱歌].收尾款)
            客户类：Client(小孩.调宋吉吉)

        缺陷：1.大量代码重复 2.只能代理Star类型的对象
    2）jdk动态代理
        角色：
            公共接口：Star
            真实角色：RealStar(周杰伦.唱歌)
            代理工厂：ProxyFactroy{生成ProxyStar(宋吉吉.面谈.订机票.签合同.[调周杰伦唱歌].收尾款)}
            客户类：Client(小孩.调宋吉吉)
    3）Cglib动态代理
        cglib和jdk动态代理的区别：cglib真实角色没有接口
3、aop的核心概念
    切点(pintcut)：要增强的方法，eg：add()、update()
    通知/增强(advice)：要搞的事情，eg：日志
        前置通知：aop:before
        后置通知：aop:after-returning【try】
        最终通知：aop:after【finally】
        异常通知：aop:after-throwing【catch】
        环绕通知：aop:around

        try{
            ...
            return aop:after-returning
        }catch(Exception e){
            ...
            aop:after-throwing
        }finally{
            ...
            aop:after
        }

    切面(aspect)：把增强应用到切点上
4、切点表达式
    格式：execution([修饰符] 返回值 报名.类名.方法名(参数))
    eg：execution(* com.by.service.*.*(..))

5、基于xml的aop配置
    1）pom.xml
        spring-context、spring-aspects、slf4j-log4j12
    2）advice
        public class MyLogAdvice {

            public void before(){
                System.out.println("前置通知....");
            }
        }
    2）aop
        <!--增强(advice)-->
        <bean id="myLogAdvice" class="com.by.advice.MyLogAdvice"></bean>

        <aop:config>
                <!--切点(pintcut)-->
                <aop:pointcut id="pointcut" expression="execution(* com.by.service.*.*(..))"/>
                <aop:aspect ref="myLogAdvice">
                            <aop:before method="before" pointcut-ref="pointcut"></aop:before>
                </aop:aspect>
        </aop:config>

九、spring基于注解的aop配置

1）pom.xml
    spring-context、spring-aspects、slf4j-log4j12
2）advice
    @Component
    @Aspect
    public class MyLogAdvice {

        @Before("execution(* com.by.service.*.*(..)")
        public void before(){
            System.out.println("前置通知....");
        }
    }
3、开启spring对aop注解的支持
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

十、spring整合mybatis

1、pom.xml
    参考6.1.1
2、applicationContext.xml
    <!--加载db.properties-->
    <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
    <!--数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driverClass}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!--sqlSessionFactory-->
    <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--告诉mybatis扫描mapper接口生成代理类，并交给spring的ioc容器去管理-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.by.mapper"></property>
        <property name="sqlSessionFactoryBeanName" value="sessionFactory"></property>
    </bean>

十一、spring整合junit

1、pom.xml
    spring-test、junit
2、test
    @RunWith(SpringJUnit4ClassRunner.class) //单元测试运行时带上spring环境
    @ContextConfiguration("classpath:applicationContext.xml")
    public class Client {
        @Autowired
        private UserService userService;
    }

十二、事务介绍

1）什么是事务？
    执行多条sql，要么全部执行，要么全部回滚
2）事务的特点
    原子性：事务是最小执行单位
    一致性：事务前后数据都是正确的
    隔离性：事务之间看不到彼此的中间状态
    持久性：事务一旦提交不可再回滚
3）mysql控制事务
    START TRANSACTION;
        sql1;
        sql2;
    COMMIT 或 ROLLBACK;
4）jdbc控制事务

    try{
        conn.setAutoCommit(false);
        ....
        conn.commit();
    }catch(Exception e){
        conn.rollback();
    }

十三、spring事务控制的api

1、PlatformTransactionManager
    作用：是一个事务管理器，负责开启、提交或回滚事务
    实现类：DataSourceTransactionManager(sqlSession)
2、TransactionDefinition
    作用：定义事务的属性
    实现类：DefaultTransactionDefinition
    属性：
        1）隔离级别【有默认值】
            DEFAULT：默认值，等价于REPEATABLE_READ
            READ_UNCOMMITTED    x         x              x
            READ_COMMITTED      脏读       x              x
            REPEATABLE_READ     脏读      不可重复度
            SERIALIZABLE        脏读      不可重复度       幻读
        2）事务的传播行为【有默认值】
            REQUIRED：默认值，methodB()会加入到methodA()事务中
        3）事务超时【有默认值】
            默认-1：永不超时
        4）是否只读【有默认值】
            readOnly = false：默认值，适用于增删改
            readOnly = true：不记录log(效率快)，适用于查询
        5）回滚规则
            可省略：运行时异常回滚，编译时异常不回滚
3、TransactionStatus
    作用：代表一个事务

十四、spring的aop控制事务

    <!--增强(advice)：要搞的事情，eg：日志、事务-->
    <tx:advice id="txManager" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="select*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="*"></tx:method>
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <!--切点(pointcut)：要增强的方法-->
        <aop:pointcut id="pointcut" expression="execution(* com.by.service.*.*(..))"/>
        <!--切面(aspect)：把增强应用到切点上-->
        <aop:advisor advice-ref="txManager" pointcut-ref="pointcut"></aop:advisor>
    </aop:config>

    注意：方法名必须和事务属性的配置保持一致，eg：get或select开头

十五、spring的注解控制事务

<!--开启spring对事务注解的支持-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

@Transactional
public class UserServiceImpl implements UserService {
}