Spring小节

Spring的总结

Spring的核心:

1. Spring的两大核心:
    1. IOC: 控制反转,将创建(实例化)对象的权利交给Spring容器去进行管理.
    2. AOP: 面向切面编程(将切面织入到连接点,使连接点称为切入点).
2. Spring是一线式框架:
    简单的来说,可以单单使用Spring实现MVC三层架构,Mybtais的数据访问层可以使用JdbcTemplate来代替.web层有SpringMVC,Spring贯穿了三层架构.
3. IOC:
    * IOC的目的是实现解耦,来降低程序的耦合度(高内聚,低耦合).
    * 实现的思想是: 反射 + 配置文件 + 工厂,使用工厂来读取配置文件,利用反射来实例化对象.
4. 初始化Spring容器:
    * ApplicationContext的三个实现接口:
        1. ClassPathXmlApplicationContext: 从类路径下加载配置文件
        2. FileSystemXmlApplicationContext: 从文件系统中加载配置文件
        3. AnnotationConfigApplicationContext: 注解开发
    * ApplicationContext与BeanFactory的区别和联系:
        ApplicationContext是BeanFactory的子接口(BeanFactory是ApplicationContext的顶级父接口).
        ApplicationContext采用立即加载的方式,加载配置文件的时候就初始化bean.
        BeanFactory采用延迟加载,使用bean的时候才会初始化.
        ApplicationContext还实现了其他的接口,具有更为丰富的功能(国际化,自动装配等)
5. Bean的实例化的三种方式:
    <!--初始化Bean有三种方式
         1. 使用Bean的id class,需要默认的构造方法
     -->
     <bean id="testService" class="cn.itcast.spring.service.impl.TestServiceImpl"></bean>
 
     <!--第二种方式 使用BeanFactory的普通方法-->
     <bean id="factory" class="cn.itcast.spring.BeanFactory"></bean>
     <bean id="testService2" factory-bean="factory" factory-method="getBean"></bean>
 
     <!--第三种方法 使用BeanFactory的静态方法-->
     <bean id="testService3" class="cn.itcast.spring.BeanFactory" factory-method="getStaticBean"></bean>
6. Bean的作用范围:
    singleton: 单例的(Spring的默认),在IOC容器中唯一
    prototype: 多例的,每次获取bean都是新对象
    request: 在web开发中,与request域绑定,获取的bean作为request的属性
    session: 在web开发中,与session域进行绑定,获取的bean作为session的属性
    global-session: 在web开发中,在集群环境下,才可以使用,如果是单个服务器,与session没有区别.
7. Bean的生命周期(指定init-method和destroy-method):
    单例:  
        初始化:加载配置文件的时候初始化,执行init-method方法
        活着:容器存在,Bean存在
        销毁:容器销毁,Bean消失,执行destroy-method方法.
        总结: 单例模式的Bean的生命周期与容器相同(容器的销毁需要手动销毁).
    多例:
        初始化: 调用getBean使用的时候初始化
        活着:对象使用就一直活着
        销毁:有java的JVM的垃圾回收机制决定
        总结:使用时初始化,销毁由JVM的垃圾回收机制决定

Spring的DI

2. 注入的三种方式
    * 构造器注入(constructor-arg标签),必须指定构造函数所有的参数
        1. type:根据参数的类型来注入数据
        2. index:根据参数的索引来注入,从0开始
        3. name:根据参数的名称来注入数据(建议使用)
        4. value:只能注入基本类型,基本类型的包装类和String
        5. ref:用于注入其他的Bean类型数据(尤其注意Date类型)
    * setter注入(依赖于set方法,使用property标签)----重要
        1. name:用于指定注入时所调用的set方法后面的变量名称
        2. value:注入基本类型,基本类型的包装类和String
        3. ref:用于注入其他的Bean类型数据(尤其注意Date类型<bean id="now" class="java.util.Date"></bean>)
    * 注解注入
3. 集合的注入(前三个为值类型的集合,后两个为键值对类型的集合,同类型的集合,使用的标签可以互换,但是建议使用的时候标签与实际类型对应)
    * 数组
        <property name="myArrs">
            <array>
                <value>AAA</value>
                <value>BBB</value>
            </array>
        </property>
    * List集合
        <property name="myLists">
            <list>
                <value>AAA</value>
                <value>BBB</value>
            </list>
        </property>
    * Set集合
        <property name="mySets">
            <set>
                <value>AAA</value>
                <value>BBB</value>
            </set>
        </property>
    * Map
        <property name="myMaps">
            <map>
                <!--如果是复杂数据类型,可以使用key-ref和value-ref-->
                <entry key="testA" value="AAA"></entry>
                <entry key="testB" value="BBB"></entry>
            </map>
        </property>
    * Properties
        <property name="properties">
            <props>
                <prop key="testA">AAA</prop>
                <prop key="testB">BBB</prop>
            </props>
        </property>

Spring的IOC注解 + xml

1. Spring的注解是为了替代xml配置文件而开发的.
2. 在xml配置文件中,修改约束,并开启注解扫描
    <context:component-scan base-package=""/>
3. 注解定义容器中的Bean
    @Component  ----> 如果不指定value,默认的bean的名称是类名的首字母小写,指定value属性bean的名称就是指定的值
    @Controller ----> 作用于表现层
    @Service ---> 作用于业务层
    @Repository ---> 作用于数据访问层
4. 注入属性的注解
    @Autowired: 按照类型注入,多个类型使用变量名来判定注入的bean.
    @Qualifiler: 配合@Autoeired注解完成注入,一起使用,使用该注解指定注入的名称.
    @Resource注解指定name属性来指定注入的名称
    @Value: 用于注入基本类型和String,上面三种是注入其他的Bean的.
5. @Scope的注解是指定作用范围
    singleton: 单例
    prototype: 多例
    request
    session
    global-session
6. 生命周期的注解:
    @PostConstruct: 指定初始化
    @PreDestroy: 指定销毁方法

全注解方式

1. 在前面的开发基础上,替换xml文件,使用配置类
    配置类就是使用@Configuration注解标识的类
2. 那包扫描使用哪个注解?
    @ComponentScan : 指定扫描的包
3. @Bean: 在方法上使用,可以将返回的值对象放入Spring容器中,需要指定name属性
4. 使用注解开发如何加载Spring的容器呢?
    想到ApplicatoinContext的三个实现类的第三个,使用AnnotationConfigApplicationCOntext(配置类的字节码)来获取Spring容器
5. 关于配置类的相关注解
    * @Configuration
    * @Import : 导入子配置类,使用该注解的类是总配置类
    * @ComponentScan : 指定扫描的包
    * @Bean: 在方法上使用,可以将返回的值对象放入Spring容器中,需要指定name属性
    * @PropertySource: 指定文件的名称和路径 @PropertySource("classpath:jdbcConfig.properties")
    * @Qualifiler 用于方法参数,可以指定注入的值,用于多个数据源等参数有多个实现类的情况.
6. 为什么使用子配置类
    将同一个业务的代码放在同比一个配置文件,不同的业务放在不同的配置文件,高内聚. 所以使用子配置类,总配置类使用@Import注解来加载子配置类

Spring整个Junit

1. 两个注解
    @Runwith
    @ContextConfiguration

SpringAOP

1. 概念:
    AOP: 面向切面编程,与OOP类似,是一种编程思想(AspectJ是基于AOP思想的一种技术)
    作用: 在不更改源码的情况下,对原始方法进行增强
    底层原理: 使用动态代理实现
2. 相关术语:
    Joinpoint(连接点): 简单来说业务层接口的所有的方法都可以作为连接点
    Pointcut(切入点): 实际被切面织入的连接点(被增强的方法)
    Advice(通知): 切面的整个实现(切面织入的目标对象,时间点以及内容),通知是共性代码抽取出来的方法
        前置,后置,异常,最终,环绕
    Target(目标对象): 切入点和连接点所属的类
    weaving(织入): 将切面代码插入到目标对象的某个方法的过程
    Aspect(切面): 交叉在各个业务逻辑中的系统服务,类似于安全验证,事务处理等等
    Advisor(顾问): 就是通知的封装和延伸,可以将通知以更为复杂的方式织入到某些方法中去
    Proxy(代理): 创建代理对象的整个过程
3. 简单总结:
    将切面织入到连接点,使得连接点成为切入点

SpringAOP的XML的配置

最前面,pom.xml的配置文件引入的依赖:
   spring-context
   spring-tx
   spring-jdbc
   mysql-connection-java
   aspectjweaver
   spring-test
   junit

1. 核心配置文件的内容
    1. 目标类的Bean的注入
    2. 通知类的Bean的注入
    3. 表明AOP的配置  <aop:config>
    4. 在config的内部配置切面 <aop:aspect>
        注意的属性有两个,一个是id(唯一标识),一个是ref(指向通知类).
    5. 在aspect内部配置通知类型
        前置通知
        后置通知
        异常通知
        最终通知
        环绕通知
        注意两个属性:
            method: 指明通知(也就是注入的方法)
            pointcut: 指明切入点(使用切入点表达式 * 包名.包名..*.*(..))
    6. 可以统一配置切入点表达式<aop:pointcut>,两个属性注意
        id: 唯一标识
        expression: 配置切入点表达式

SpringAOP的注解的配置

1. 核心配置文件:
    1. 开启注解扫描: <context:component-scan base-package="com.itheima"></context:component-scan>
    2. 开启Spring对AOP注解的支持 <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
2. 对于目标类,需要添加bean的注解
3. 通知类需要添加bean的注解支持
    1. 通知类需要添加切面注解 @Aspect
    2. 通知类需要定义切面表达式(利用方法,唯一标识就是方法名)
    3. 对通知添加通知类型的注解(前置,后置,最终,异常,环绕),注意的是环绕通知的ProceedingJoinPoint
4. 测试类:
    使用ClassPathXmlApplicationContext来创建ApplicationContext的实例
    
5. 注意顺序问题:
    对于注解来说,前置,后置,最终,异常的顺序是=====> 前置 -> 最终 -> 后置    注意的是后置和异常同一时刻只能执行一个,如果有环绕通知,环绕通知最先执行
        我是前置通知
        添加账户
        我是最终通知
        我是后置通知
    有异常的时候:
        我是前置通知
        添加账户
        我是最终通知
        我是异常通知

环绕通知的应用场景:

事务管理
日志记录
性能检测

SpringJdbcTemplate

1. 首先引入依赖:
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.1.0.RELEASE</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>5.1.0.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.46</version>
    </dependency>
2. 对于dao接口的实现类,继承JdbcDaoSupport,直接使用getJdbcTemplate()就可以获取JdbcTemplate对象
3. 核心配置文件的配置:
    1. 注入数据访问层接口实现类的bean,中间使用setter注入JdbcTemplate
    2. 注入JdbcTemplate的bean,中间使用setter注入DataSource
    3. 注入dataSource,使用Spring自带的连接池DriverManagerDataSource,使用setter注入四要素
4. 测试执行就好  

Spring事务管理

1. 事务控制在业务(Service)层
2. Spring事务管理的API三大接口  -----> spring-tx包下
    1. PlatformTransactionManager : 平台事务管理器
        DataSourceTransactionManager ----> springjdbc,mybatis
        HibernateTransactionManager ----> hibernate
    2. TransactionDefinition : 事务定义接口(包含了事务的基本属性信息)
    3. TransactionStatus : 事务状态接口(事务状态的一些基本信息)
3. 事务管理的方式: 
    * 声明式事务管理(重点掌握)
        1. XML
        2. 注解
    * 编程式事务管理(了解)

事务管理之环境依赖

1. 环境搭建(依赖):
    spring-context : 核心
    spring-tx : 事务管理
    spring-jdbc : 数据库
    mysql-connection-java : 数据库连接
    aspectjweave : aop
    spring-test : 测试,与junit进行整合
    junit : 测试

事务管理之基于XML的声明式事务控制

pom文件的依赖：
    spring-context
    spring-tx
    spring-jdbc
    mysql-connection-java
    aspectjweaver
    spring-test
    junit
   
1. 核心配置文件配置(aop,tx的约束):
    1. 声明service的bean（注入dao）
    2. 声明dao的bean（注入dataSource），dao实现类继承JdbcDaoSupport，使用Spring提供的模板
    3. 声明dataSource，使用spring的连接池 DriverManagerDataSource，注入四要素
    4. 配置事务管理器(<bean>) DataSourceTransactionManager，需要注入dataSource
    5. 配置事务的通知 <tx:advice>,其实就是事务管理的通知
        id属性: 唯一标识
        transaction-manager: 给事务通知提供一个事务管理器的引用
    6. 配置AOP的通用切入点表达式<aop:config>
        配置切入点表达式 <aop:pointcut>
        建立切入点表达式与事务通知之间的关系 <aop:advisor>,内部其实是环绕通知
            advice_ref
            pointcut-ref
    7. 配置事务的属性(在事务通知标签内部配置)
        <tx:attribute><tx:method name="find*" propagation="" read-only="" /></tx:attribute>,name用来配置方法,可以使用表达式
        isolation: 事务的隔离级别,默认值是default
        propagation: 指定事务的传播行为,默认是REQUIRED,表示一定会有事务,增删改的选择.如果是查询,可以说那个SUPPORTS
        read-only: 用于指定事务是否只读,只有查询方法才能设置为true,默认是false,表示读写
        timeout: 指定事务的超时时间,默认值是-1,表示永不超时,单位是秒
        
        rollback-for: 用于指定一个异常，当产生该异常时，事务回滚，产生其他异常时，事务不回滚。没有默认值。默认回滚运行期异常
        no-rollback-for: 用于指定一个异常，当产生该异常时，事务不回滚，产生其他异常时事务回滚。没有默认值。默认回滚运行期异常
    8. 测试的时候使用Junit和Spring的整合进行测试
        @RunWith(SpringJUnit4ClassRunner.class)
        @ContextConfiguration(locations = {"classpath:bean.xml"})
        public class TxTest {
        
            @Autowired
            private AccountService accountService;
        
            @Test
            public void testTransfer(){
                accountService.tranfer("aaa","bbb",100f);
            }
        }
        如果使用main方法进行测试注意的是获取bean的时候获取的应该是接口，因为使用的是java的动态代理，获取的代理对象与原来对象的关系是兄弟关系，如果直接获取实现类的对象，会报代理异常错误
        
2. 关于Spring事务控制异常回滚
    默认回滚运行期异常,如果想要控制非运行期异常也回滚,则使用rollback-for="java.lang.Exception"来指定,指定多个异常使用逗号隔开

事务管理之基于注解的事务控制（在前一个项目的基础上修改）

1. 核心配置文件(aop,tx,context)
    1. 开启注解扫描: <context:component-scan>
    2. 配置平台事务管理器 <bean>指定事务管理器  DataSourceTransactionManager
    3. 开启Spring对注解事务的支持: <tx:annotation-driver transaction-manager="">
    4. 在目标类上面添加 @Transactional()  还可以配置属性，属性一般都有默认值，可以查看源码试试
        注意的是 @Transactional()可以指定在方法上面,单独为这个方法指定事务属性
2. 替换核心配置文件的内容：
    1. 替换service的bean的注入
    2. 删除事务通知和AOP切面就可以了
3. 直接进行测试
4. @Transactional作用位置的区别
    > 作用于类上,当前类所有的方法具有事务控制
    > 作用在方法上,当前类的所有方法都具有事务
    > 接口上,当前接口的实现类的所有方法具有事务

Spring的全注解配置方式(使用下面的方式替换xml配置文件)

首先先删除xml配置文件
1. 核心配置类
    @Configuration
    @ComponentScan
    @Import     // 导入其他两个配置文件
    @PropertySource({"classpath:"})
    @EnableTransactionMangement       // 开启事务注解支持
2. 子配置类(两个子配置类，一个事务，一个JDBC连接)
    @Configuration
    @Bean(name="")
    @Value
    在jdbc连接配置类中配置DataSource和JdbcTemplate
    在事务配置类中配置   用于创建事务管理器对象PlatformTransactionManager   Bean的名字为transactionManager