欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Spring小节

程序员文章站 2022-03-01 20:52:57
...

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

上一篇: 11 ,小节 :

下一篇: const 小节