Java必学的Spring5学习大总结

　　一、了解 Spring 基本介绍、主要思想 IoC/DI1、了解 Spring 基本介绍(1) Spring是什么？
　　Spring 是一个   轻量级   的   DI/IoC 和 AOP 容器   的   开源框架   ，致力于构建致力于构建  轻量级的 JavaEE 应用   ，  简化应用开发    ，本身涵盖了传统应用开发，还拓展到移动端，大数据等领域。 (2) Spring有什么优点？与作用？
　　① Spring 能帮我们低侵入/低耦合地根据   配置文件   创建及组装对象之间的依赖  关系。
　　② Spring   面向切面编程    能帮助我们无耦合的实现日志记录，性能统计，安全控制等。
　　③ Spring 能非常简单的且强大的   声明式事务管理    (通过配置完成事务，不用修改代码)。
　　④ Spring 提供了与第三方   数据访问框架   （如 Hibernate、JPA）   无缝集成    ，且自己也提供了一套  JDBC 模板   来方便数据库访问。
　　⑤ Spring 提供与第三方   Web   （如 Struts1/2、JSF）   框架     无缝集成   ，且自己也提供了一套 Spring MVC 框架，来方便 Web 层搭建。
　　⑥ Spring 能方便的与如 Java Mail、任务调度、缓存框架等技术整合，降低开发难度。  2、主要思想 IoC/DI
　　Spring 是一个DI容器或IoC容器   （DI和IoC 思想差不多）。掌握着  创建对象和构建对象之间的依赖  的  控制权    。   IoC：Inversion of Control（控制反转）:
　　一种设计思想   。 其本意是是 将原本在程序中手动创建对象的控制权，交由 Spring 框架来管理 。    DI：Dependency Injection（依赖注入）:
　　一种设计思想   。 具体是指 Spring 创建对象的过程中，将对象依赖属性（常量，对象，集合）通过   配置   设值给该对象。 二、掌握Spring 基本使用、Spring 获取bean对象的方式、Spring 标签 import的引入配置1、掌握Spring 基本使用(1) 依赖jar包：spring-beans.jar  spring-core.jar  commons-logging.jar  (2) 配置：创建applicationContext.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 https://www.springframework.org/schema/beans/spring-beans.xsd＂  >     < bean   id= ＂hello＂   class= ＂com.shan.hello.Hello＂  >     < property   name= ＂password＂   value= ＂123＂  /> < property   name= ＂username＂   value= ＂shan＂  /> bean  > beans  > (3) 使用：@Test 	void testIoC() throws Exception { 		Hello hello = null; 		//========================= 		//1、加载配置文件：从classpath路径去寻找配置文件，创建资源对象 		Resource resource = new ClassPathResource(＂applicationContext.xml＂);	 		//2、创建IoC容器：创建spring的工厂对象（IoC容器对象） 		BeanFactory factory = new XmlBeanFactory(resource); 		//3、从Ioc容器获取对象：从spring IoC 容器(就是factory 工厂对象)中获取指定名称的对象 		hello = (Hello)factory.getBean(＂hello＂); 		//========================= 		hello.printUser(); 	}  从例子，可以看出，spring不仅帮我们创建对象，还帮我们把对象需要的数据给设置进来（对象的属性依赖）2、Spring 获取bean对象的方式推荐使用：bean的名称+类型： T getBean(String name, Class requiredType) 根据bean对象在容器中的 名称+类型 来获取  @Test    void   testIoC() throws Exception { Hello hello =  null  ;  //=========================    //1、加载配置文件：从classpath路径去寻找配置文件，创建资源对象   Resource resource =  new   ClassPathResource( ＂applicationContext.xml＂  );  //2、创建IoC容器：创建spring的工厂对象（IoC容器对象）   BeanFactory  factory   =  new   XmlBeanFactory(resource);  //3、从Ioc容器获取对象：从spring IoC 容器(就是factory 工厂对象)中获取指定名称的对象    //方式(推荐): T getBean(String name, Class requiredType) 根据bean对象在容器中的 名称+类型 来获取   hello =  factory  .getBean( ＂hello＂  , Hello. class  );  //=========================   hello.printUser(); } 3、Spring 标签 import的引入配置前缀 classpath classpath 三、Spring 核心对象BeanFactory和Bean、Spring的配置方式、了解Spring管理bean的原理1、Spring 核心对象BeanFactory和BeanBeanFactory：是Spring的IoC容器（   容器--管理对象的生命周期   ），生产 bean 对象的工厂，负责配置，创建和管理 bean。 bean：被 Spring IoC 容器管理的对象称之为bean。  2、Spring的配置方式  元数据的配置有三种方式：
　　XML-based configuration (   xml配置文件   )
　　Annotation-based configuration （   注解    ）
　　Java-based configuration （   基于java-config   ） 3、了解Spring管理bean的原理底层是：   反射   (获取构造器实例对象)+  内省机制   (设置属性值) ① 通过 Resource 对象加载配置文件② 解析配置文件，得到指定名称的 bean③ 解析 bean 元素，id 作为 bean 的名字，class 用于反射得到 bean 的实例注意：此时，bean 类必须存在一个   无参数构造器   (且该无参构造器  和访问权限无关    )； ④ 调用 getBean 方法的时候，从容器中返回对象实例；  结论：就是把代码从 JAVA 文件中转移到了 XML 中。四、使用Spring的测试框架 相对于传统测试方式，spring测试框架会帮我们关闭对象资源，而使用传统方式，不会正常关闭spring容器。1、依赖jar包：spring-test.jar  spring-context.jar  spring-aop.jar  spring-expression.jar  2、配置文件：
　　SpringTestTest5-context.xml 文件（   文件名必须是测试类-context   ，因为需要跟测试类名对应上）：  <?xml version=＂1.0＂ encoding=＂UTF-8＂?>             	 3、测试类：
　　SpringTestTest5 类：  //SpringTest 案例测试  //运行 Spring JUnit5 @SpringJUnitConfig public class SpringTestTest5 { 	//表示自动按照类型 Spring容器中去找到bean对象，并设置给该字段 	@Autowired 	private SomeBean bean; 	 	@Test 	void testIoC() throws Exception { 		bean.doWork(); 	} }五、Spring的核心 IoC（基于xml）1、ApplicationContext 和 BeanFactory 创建对象的区别BeanFactory 在创建Spring容器的时候，并不会立马创建容器中管理的Bean对象，需要等到获取某一个 bean 的时候才会创建该 bean--延迟初始化。（   懒加载    ） ApplicationContext 在启动 Spring 容器的时候就会创建所有的 bean（   在 Web 应用使用Application    ） 2、常用实例化bean的方式 和 实现FactoryBean接口实例化的方式(1)实例化bean的方式：构造器实例化（   bean 中有 无参数构造器   ），标准、  常用   。    < bean   id= ＂someBean＂   class= ＂com.shan.spring_test.SomeBean＂  /> (2)实现FactoryBean接口实例化的方式：类要实现接口FactoryBean：  public    class    DogFactory    implements    FactoryBean  < Dog  >{  @Override    public   Dog  getObject  ()  throws   Exception { Dog dog =  new   Dog();  return   dog; }  @Override    public   Class<?> getObjectType() {  return   Dog.class; } }    < bean   id= ＂dog＂   class= ＂com.shan._04_factory_bean.DogFactory＂  /> 3、 bean作用域scope、初始化init-method和销毁destroy-method(1) bean作用域scope缺省和常用的情况是单例 singleton  单例和多例： singleton: 单例(默认的作用域） prototype: 多例  在web应用中(request、session、application)  globalSession: 一般用于 Porlet 应用环境 , 分布式系统存在全局 session 概念（单点登录）  websocket：将一个bean定义定义到WebSocket的生命周期  (2) bean初始化和销毁：属性init-method=＂该类中初始化方法名＂ 和 属性destroy-method=＂该类中销毁方法名＂  没有使用spring的测试框架的话，就不能正常关闭IoC容器，即销毁bean对象了（可以手动关闭）  六、Spring的核心 DI（基于xml）：
　　({color{Violet}{  DI跟IoC差不多啦，细节就是DI还负责管理bean对象的属性}})  1、xml配置注入属性值：
　　配置与注入：  常量类型 配置value--->注入setter方法  对象类型 配置ref--->注入setter方法  集合类型 配置各自集合对应的元素 ...--->注入setter方法  1、通过XML配置装配（1）XML 自动装配（不推荐）通过bean元素的属性 autowire 自动装配 （2）setter注入 [ 属性注入（根据类型区分）]   （   常用   ） 注入常量  value  <  bean   id= ＂person＂   class= ＂com.shan.di_setter.Person＂  > < property   name= ＂name＂   value= ＂shan＂  /> < property   name= ＂age＂   value= ＂22＂  /> < property   name= ＂salary＂   value= ＂10000＂  /> bean  >   （ 常用  ） 注入对象 ref <  bean   id= ＂cat＂   class= ＂com.shan.di_setter2.Cat＂  > < property   name= ＂name＂   value= ＂kity＂  /> bean  > < bean   id= ＂person＂   class= ＂com.shan.di_setter2.Person＂  > < property   name= ＂name＂   value= ＂shan＂  /> < property   name= ＂age＂   value= ＂22＂  /> < property   name= ＂cat＂   ref= ＂cat＂  /> bean  >   注入集合 、 、 、 、 ＂person＂    class  = ＂com.shan.di_setter3.Person＂  >     < property   name= ＂set＂  > < set  > < value  >set1value  > < value  >set2value  > set  > property  >     < property   name= ＂list＂  > < list  > < value  >list1value  > list  > property  >     < property   name= ＂array＂  > < array  > < value  >array1value  > array  > property  >     < property   name= ＂map＂  > < map  > < entry   key= ＂key1＂   value= ＂value1＂  /> map  > property  >     < property   name= ＂prop＂  > < value  > p1=v1 p2=v2 value  > property  > bean  > 2、bean元素继承 （本质是xml配置内容的拷贝）通过abstract属性进行抽取  通过parent属性进行引入
　　3、属性注入应用---配置数据库连接池动态加载配置文件(db.properties---数据库连接的配置信息)    使用 ${} 动态引入属性值  (1) 配置数据库连接池 	 		 		 		 		 		 	(2) db.properties---数据库连接的配置信息(3) property place holder  要是使用标签Context，需要先引入Context的约束（在beans的基础进行修改即可）：
　　context:property-placeholder 属性占位符           使用 ${} 动态引入属性值 	 		 		 		 		 		 	七、Spring使用注解配置1、注解三要素：注解本身、被贴、第三方程序(赋予注解的特殊功能)
　　对于IoC注解、DI注解：他们的第三方程序是他们对应的解析器。  IoC注解：组件扫描器   DI注解：注解配置   2、DI 注解：@Autowired、@Resource、@Valuevalue注解的威力：结合动态properties配置文件引入值变量 例如：@Value(＂${service.port}＂)  (1) 通过注解注入属性值  配置与注入：常量类型 配置value--->注入@Value  对象类型 配置ref--->注入@Autowired/@Resource  (2)IoC注解：@Component、@Scope、@PostConstruct、@PreDestroy  使用注解@Component（配置Bean）//相当于  @Component(＂dataSource＂) public class MyDataSource {  }  bean组件版型：@Component泛指组件@Repository持久层@Service业务层@Controller控制层  作用域注解、初始化和销毁注解：@Scope、@PostConstruct、@PreDestroy
　　({color{Violet}{  其中初始化和销毁注解[依赖：javax.annotation-api.jar]}})  八、Spring AOP1、了解AOP思想[面向切面编程的思想]、AOP思想的原理(1) 面向切面编程的思想：
　　利用一种称为＂横切＂的技术，剖开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为＂Aspect＂，即切面。  切面：   把一个个的横切关注点放到某个模块中去   ，称之为切面。 那么每一个的切面都能影响业务的某一种功能，   切面的目的就是功能增强   ， 如日志切面就是一个横切关注点，应用中许多方法需要做日志记录的只需要插入日志的切面即可.
　　(2) AOP思想的原理：动态代理2、Pointcot语法找到具体的某个方法--   哪个包.哪个类.哪个方法  execution(<修饰符>? <返回类型> <声明类型>? <方法名>(<参数>) <异常>)切入点表达式中的通配符（   看具体的方法，先从方法名位置开始看   ）： *：匹配任何部分，但是只能表示一个单词。  ..：可用于全限定名中和方法参数中，分别   表示子包和 0 到 N 个参数   。  3、AOP 开发：(1) 依赖jar包：spring-aop.jar  com.springsource.org.aopalliance.jar [spring5的spring-aop.jar已经包含]  com.springsource.org.aspectj.weaver.jar  (2) 配置：引入AOP的约束：
　　AOP的3W-what、where、when   	 	 	 	  		   		  			 			 			 			 			 			 			 				 		 	4、AOP增强的分类  根据被增强的方法的执行时机分为：前置增强、后置增强、异常增强、最终增强、环绕增强前置增强：   权限控制、日志记录   等 [被增强的方法执行之前]  后置增强：   提交事务、统计分析数据结果   等 [被增强的方法正常执行之后(中途没有异常)]  最终增强：   回滚事务、记录日志异常信息   等 [被增强的方法出现异常]  最终增强：   释放资源   等 [finally最后操作]  环绕增强：   缓存、性能日志、权限、事务管理   等 [可以自定义在被增强方法的什么时机执行(   返回一个Object   ，参数processdingJoinpoint)]  5、获取被增强方法的信息, 并且可以传递给增强方法【参数Joinpoint类】Joinpoint类   连接点，访问被增强方法的真实对象，代理对象，方法参数等 可以作为前置、后置、异常、最终增强方法的参数，   第一个参数  //可以作为前置、后置、异常、最终增强方法的参数，**`第一个参数`**   public    void    open  (JoinPoint jp) { System. out  .println( ＂开启事务~＂  ); System. out  .println( ＂代理对象:＂   +jp.getThis().getClass()); System. out  .println( ＂目标对象:＂   +jp.getTarget().getClass()); System. out  .println( ＂被增强方法的参数:＂   +Arrays.toString(jp.getArgs())); System. out  .println( ＂连接点方法的签名:＂   +jp.getSignature()); System. out  .println( ＂当前连接点的类型:＂   +jp.getKind()); } 5-2、环绕增强方法调用真实对象的方法【参数processdingJoinpoint】参数processdingJoinpoint：是JointPoin 的子类，只能用于环绕增强，   作为第一个参数  还可以调用真实对象中被增强的方法。  //调用真实对象的方法 ret = pjp.proceed(); public Object aroundMethod(ProceedingJoinPoint pjp) { 		Object ret = null; 		System.out.println(＂开启事务~＂); 		try { 			ret = pjp.proceed();//调用真实对象的方法 			System.out.println(＂调用真实对象的方法...~＂); 			System.out.println(＂提交事务~＂); 		} catch (Throwable e) { 			System.out.println(＂回滚事务~,错误信息:＂ + e.getMessage()); 		}finally { 			System.out.println(＂关闭资源~＂); 		} 		return ret; 	}6、使用注解配置AOP(1) AOP注解的解析器【第三方程序,赋予注解的特殊功能】：使用cglib注解：配置属性proxy-target-class=＂true＂    	   (2) 使用注解@Aspect（配置一个AOP切面）配置where 配置when @Component@Aspect //配置一个AOP切面 public class TransactionManager { 	 	//where 	//xml: 	@Pointcut(＂execution(* com.shan.service..*Service*.*(..))＂) 	public void txPoint() { 		 	} 	 	//@Before(＂txPoint()＂) 	public void open(JoinPoint jp) { 		System.out.println(＂开启事务~＂); 	}  	//@AfterReturning(＂txPoint()＂) 	public void commit() { 		System.out.println(＂提交事务~＂); 	} 	//@AfterThrowing(value=＂txPoint()＂, throwing=＂ex＂) 	public void rollback(Throwable ex) { 		System.out.println(＂回滚事务~,异常信息：＂ +ex.getMessage()); 	} 	//@After(＂txPoint()＂) 	public void close() { 		System.out.println(＂关闭资源~＂); 	} 	 	@Around(＂txPoint()＂) 	public Object aroundMethod(ProceedingJoinPoint pjp) { 		Object ret = null; 		System.out.println(＂开启事务~＂); 		try { 			ret = pjp.proceed();//调用真实对象的方法 			System.out.println(＂调用真实对象的方法...~＂); 			System.out.println(＂提交事务~＂); 		} catch (Throwable e) { 			System.out.println(＂回滚事务~,错误信息:＂ + e.getMessage()); 		}finally { 			System.out.println(＂关闭资源~＂); 		} 		return ret; 	} }九、Spring DAO1、模板类和基类：
　　2、pring JDBC 【JDBCTemplate 模板类】(1) 依赖jar包：mysql-connector-java.jar 【还可以使用德鲁伊连接池：druid.jar】  spring-jdbc.jar  spring-tx.jar  (2) 总结JdbcTemplate模板类-处理CRUD 操作//DML操作： public update(String sql, Object...args) 参数：sql     ?占位符对应的参数 返回：受影响的行数  //DQL 操作： public List query(String sql, Object...args, RowMapper rowMapper) 参数：sql     ?占位符对应的参数     结果集处理器 返回：多行结果集封装的list3、模板类JdbcTemplate的问题与解决NameParameterJdbcTemplate(1) 问题：  在模板类JdbcTemplate中使用的占位符 ？【顺序占位符】,需要数第几个，然后写对应的参数，参数多了麻烦  面对集合查询 in查询时(不确定参数个数)， select * from employee where id in .....in 后边不知道该怎么写，是应该写一个？还是（多少个？，都是不确定的）  (2) 解决：使用NameParameterJdbcTemplate命名的参数JdbcTemplate模板，其实就是在JdbcTemplate外面套一层。  允许使用 xx 来给占位参数起名称，我们需要给名称xx的位置设置参数。
　　举例：  public int countOfActorsByFirstName(String firstName) {     String sql = ＂select count(*) from T_ACTOR where first_name = :first_name＂;     Map namedParameters = Collections.singletonMap(＂first_name＂, firstName);     return this.namedParameterJdbcTemplate.queryForObject(sql, namedParameters,  Integer.class); }十、Spring ORM --- 集成mybatis框架十一、Spring tx1、Spring 的事务管理主要包括 3 个 api：PlatformTransactionManager：根据 TransactionDefinition 提供的事务属性配置信息，   创建事务   。 TransactionDefinition：   封装事务的隔离级别和超时时间   ，是否为只读事务和事务的隔离级别和传播规则等  事务属性   . TransactionStatus：   封装了事务的具体运行状态   。如是否是新开启事务，是否已经提交事务，设置当前事务为rollback-only.   记：常用的事务管理器：JDBC/MyBatis：DataSourceTransactionManager  Hibernate： HibernateTransactionManager  2、事务传播规则 TransactionDefinition 和 常用的情况(1) 事务传播规则：
　　在一个事务方法中，调用了其他事务的方法，此时事务该如何传递，按照什么规则传播.  (2) 常用的情况：  情况一：需要尊重／遵从当前事务REQUIRED：(   常用    ）必须存在一个事务，如果当前存在一个事务，则加入到该事务中，否则，新建一个事务.   情况二：不遵从当前事务的REQUIRES＿NEW：(   常用    ）不管当前是否存在事务，都会新开启一个事务.必须是一个新的事务.   情况三：寄生事务（外部事务／内部事务／嵌套事务）NESTED：寄生事务，如果当前存在事务，则在内部事务内执行.如果当前不存在事务，则创建一个新的事务.  3、事务配置(基于xml和注解)(1) 基于xml：事务增强—本质就是AOP增强what、when、where 	 	 		 	 	 	 	 		 			 		 	 	 	 	 		 		 	(2) 使用注解配置jdbc事务：tx注解解析器、@Transactional注解：@Transactional  注解属性：name、propagation、isolation、timeout、read-only、rollback-for、no-rollback-for  注解第三方解析：  <  bean   id= ＂txManager＂   class= ＂org.springframework.jdbc.datasource.DataSourceTransactionManager＂  > < property   name= ＂dataSource＂   ref= ＂dataSource＂  >property  > bean  >     < tx:annotation-driven   transaction-manager= ＂txManager＂  />   注解@Transactional使用：  @Service@Transactional    public    class    AccountServiceImpl    implements    IAccountService  {  @Autowired    private   IAccountDAO dao;  @Override    public    void    trans  (Long outId, Long inId,  int   money) { dao.transOut(outId, money);  int   a =  1  / 0  ;  //算术异常   dao.transIn(inId, money); }  //若是有查询方法，可以再贴注解@Transactional添加注解属性    @Transactional  (readOnly =  true  )  public    void    listXX  () { } } (3) 事务配置(基于注解+Java Config 配置)注解：  ({color{Blue}{@Configuration}}) 配置  ({color{Blue}{@import(配置子类)}})  ({color{Blue}{@Bean}}) 配置创建bean对象  ({color{Blue}{@ComponentScan}}) IoC注解解析器  ({color{Blue}{@EnableTransactionManagement}}) 事务注解解析器  @Transactional 配置jdbc事务  @PropertySource 配置引入的属性文件资源  ({color{Gray}{@Component}}) 泛指组件  ({color{Gray}{@Repository}}) 持久层  ({color{Gray}{@Service}}) 业务层  ({color{Gray}{@Controller}}) 控制层  @Value配置注入属性值  @Autowired配置注入属性值