经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Java » 查看文章
Spring小节
来源：cnblogs　　作者：我想回家　　时间：2018/10/10 9:12:46　　对本文有异议

Spring的总结

Spring的核心:

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

Spring的DI

  1. 2. 注入的三种方式
  2.     * 构造器注入(constructor-arg标签),必须指定构造函数所有的参数
  3.         1. type:根据参数的类型来注入数据
  4.         2. index:根据参数的索引来注入,从0开始
  5.         3. name:根据参数的名称来注入数据(建议使用)
  6.         4. value:只能注入基本类型,基本类型的包装类和String
  7.         5. ref:用于注入其他的Bean类型数据(尤其注意Date类型)
  8.     * setter注入(依赖于set方法,使用property标签)----重要
  9.         1. name:用于指定注入时所调用的set方法后面的变量名称
  10.         2. value:注入基本类型,基本类型的包装类和String
  11.         3. ref:用于注入其他的Bean类型数据(尤其注意Date类型<bean id="now" class="java.util.Date"></bean>)
  12.     * 注解注入
  13. 3. 集合的注入(前三个为值类型的集合,后两个为键值对类型的集合,同类型的集合,使用的标签可以互换,但是建议使用的时候标签与实际类型对应)
  14.     * 数组
  15.         <property name="myArrs">
  16.             <array>
  17.                 <value>AAA</value>
  18.                 <value>BBB</value>
  19.             </array>
  20.         </property>
  21.     * List集合
  22.         <property name="myLists">
  23.             <list>
  24.                 <value>AAA</value>
  25.                 <value>BBB</value>
  26.             </list>
  27.         </property>
  28.     * Set集合
  29.         <property name="mySets">
  30.             <set>
  31.                 <value>AAA</value>
  32.                 <value>BBB</value>
  33.             </set>
  34.         </property>
  35.     * Map
  36.         <property name="myMaps">
  37.             <map>
  38.                 <!--如果是复杂数据类型,可以使用key-ref和value-ref-->
  39.                 <entry key="testA" value="AAA"></entry>
  40.                 <entry key="testB" value="BBB"></entry>
  41.             </map>
  42.         </property>
  43.     * Properties
  44.         <property name="properties">
  45.             <props>
  46.                 <prop key="testA">AAA</prop>
  47.                 <prop key="testB">BBB</prop>
  48.             </props>
  49.         </property>
  50.

Spring的IOC注解 + xml

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

全注解方式

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

Spring整个Junit

  1. 1. 两个注解
  2.     @Runwith
  3.     @ContextConfiguration
  4.

SpringAOP

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

SpringAOP的XML的配置

  1. 最前面,pom.xml的配置文件引入的依赖:
  2.    spring-context
  3.    spring-tx
  4.    spring-jdbc
  5.    mysql-connection-java
  6.    aspectjweaver
  7.    spring-test
  8.    junit
  10. 1. 核心配置文件的内容
  11.     1. 目标类的Bean的注入
  12.     2. 通知类的Bean的注入
  13.     3. 表明AOP的配置  <aop:config>
  14.     4. 在config的内部配置切面 <aop:aspect>
  15.         注意的属性有两个,一个是id(唯一标识),一个是ref(指向通知类).
  16.     5. 在aspect内部配置通知类型
  17.         前置通知
  18.         后置通知
  19.         异常通知
  20.         最终通知
  21.         环绕通知
  22.         注意两个属性:
  23.             method: 指明通知(也就是注入的方法)
  24.             pointcut: 指明切入点(使用切入点表达式 * 包名.包名..*.*(..))
  25.     6. 可以统一配置切入点表达式<aop:pointcut>,两个属性注意
  26.         id: 唯一标识
  27.         expression: 配置切入点表达式

SpringAOP的注解的配置

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

环绕通知的应用场景:

  1. 事务管理
  2. 日志记录
  3. 性能检测
  4.

SpringJdbcTemplate

  1. 1. 首先引入依赖:
  2.     <dependency>
  3.         <groupId>org.springframework</groupId>
  4.         <artifactId>spring-context</artifactId>
  5.         <version>5.0.2.RELEASE</version>
  6.     </dependency>
  8.     <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
  9.     <dependency>
  10.         <groupId>org.springframework</groupId>
  11.         <artifactId>spring-jdbc</artifactId>
  12.         <version>5.1.0.RELEASE</version>
  13.     </dependency>
  15.     <!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
  16.     <dependency>
  17.         <groupId>org.springframework</groupId>
  18.         <artifactId>spring-tx</artifactId>
  19.         <version>5.1.0.RELEASE</version>
  20.     </dependency>
  22.     <dependency>
  23.         <groupId>mysql</groupId>
  24.         <artifactId>mysql-connector-java</artifactId>
  25.         <version>5.1.46</version>
  26.     </dependency>
  27. 2. 对于dao接口的实现类,继承JdbcDaoSupport,直接使用getJdbcTemplate()就可以获取JdbcTemplate对象
  28. 3. 核心配置文件的配置:
  29.     1. 注入数据访问层接口实现类的bean,中间使用setter注入JdbcTemplate
  30.     2. 注入JdbcTemplate的bean,中间使用setter注入DataSource
  31.     3. 注入dataSource,使用Spring自带的连接池DriverManagerDataSource,使用setter注入四要素
  32. 4. 测试执行就好

Spring事务管理

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

事务管理之环境依赖

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

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

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

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

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

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

  1. 首先先删除xml配置文件
  2. 1. 核心配置类
  3.     @Configuration
  4.     @ComponentScan
  5.     @Import     // 导入其他两个配置文件
  6.     @PropertySource({"classpath:"})
  7.     @EnableTransactionMangement       // 开启事务注解支持
  8. 2. 子配置类(两个子配置类，一个事务，一个JDBC连接)
  9.     @Configuration
  10.     @Bean(name="")
  11.     @Value
  12.     在jdbc连接配置类中配置DataSource和JdbcTemplate
  13.     在事务配置类中配置   用于创建事务管理器对象PlatformTransactionManager   Bean的名字为transactionManager
 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Java热门文章

  • 【IDEA】Application context not configured for this file
  • [IDEA] chapter_reader - idea看小说插件 idea阅读插件 idea摸鱼插件
  • thrift常见异常及原因分析
  • Java 调用 PaddleDetection 模型
  • JVM 详解，大白话带你认识 JVM
  • spring-boot-2.0.3不一样系列之番外篇 - @Configuration、Condition与@Conditional
  • Java Comparator.comparing比较导致空指针异常的解决
  • Java使用EasyExcel进行单元格合并的问题详解
  • 死磕 java集合之ArrayBlockingQueue源码分析
  • Java基础之集合Set详解

    • Java推荐文章

  • 面试场景题：一次关于线程池使用场景的讨论。
  • 前端黑科技：使用 JavaScript 实现网页扫码功能
  • 聊一聊 Netty 数据搬运工 ByteBuf 体系的设计与实现
  • 简单设计一个JAVA并行处理工具类
  • 【杂谈】JPA乐观锁改悲观锁遇到的一些问题与思考
  • 认识netty的基本组件
  • Jenkins如何使用CrumbIssuer防御CSRF攻击
  • 如何平稳地从nacos迁移到r-nacos？
  • 线程池遇到父子任务，有大坑，要注意！
  • Java JVM——12. 垃圾回收理论概述

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号