spring

spring框架

1. spring是一个大家族，有很多单独的框架合并在一起的，包括有：
   springMVC，spring，springboot，springcloud

2. spring减轻对项目模块之间的管理，类和类之间的管理，帮助开发人员创建对象，管理对象之间的关系。
   spring的核心技术ioc，aop，能实现模块之间的解耦合。
   ioc:Inversion of Control 控制反转
   AOP:Aspect Oriented Programming 面向切片编程

3. spring中的依赖，Class A要使用Class B中的属性和方法，就说明Class A依赖于Class B
   maven是管理jar包的要用到的，spring是写项目时要用到的。两者有所不同。

第二章 IOC inversion of control 控制反转

​ 1.IOC：是一个理论，概念，思想。
​ 把对象的创建，赋值，管理工作都交给代码之外的容器来实现。也就是对象的创建是有其他外部资源完成的。

​ 控制：创建对象，对象的属性赋值，对象之间的关系管理。
​ 反转：把创建对象的权力转移给代码之外的容器来实现由容器代替开发人员管理对象，创建对象。
​ 正传：由开发人员在代码中，使用new构造方法创建对象，开发人员主动管理对象。
​ 例如：Student stu = new Student();
​ 控制反转：由容器创建对象，对对象的属性进行赋值和对象之间的关系管理
​ 容器：是一个服务器软件，是一个框架（例如spring）

​ ioc:目的就是减少对代码的改动，也能实现不同的功能。实现解耦合

2. Java中创建对象的方法：
   1.new
   2.反射

   //反射如何创建对象？
   //首先如何获取反射
   //第一种
   Class c1 = Class.forName("String");
   //第二种
   Class c2 = String.class;
   //第三种
   Class c3 = new String().getClass();
   //创建对象
   String s = c1.newInstance();
   

   3.序列化

   //插嘴，序列化和反序列化如何实现？
   Student student = new student();//序列化的类必须实现Serializable接口
   FileOutputStream fos = new FileOutputStream("file_name");//序列化后的文件名
   
   //序列化
   ObjectOutputStream oos = new ObjectOutputStream(fos);//将节点流包装成处理流，Java io部分的知识点
   fos.writeObject(student);//序列化
   fos.flush(); //刷新缓冲区立刻写入文件并清空缓冲区
   fos.close();
   
   //反序列化
   FileInputStream fis = new FileInputStream("file_name");
   ObjectInputStream ois = new ObjectInputStream(fis);
   Student stu = (Student)fis.readObject();
   

   4.克隆

   //再提一嘴，克隆又是如何实现的呢？
   Student s2 = s1.clone();
   //必须实现Clonable接口和clone方法
   class Student implements Clonable{
   	public Student clone() throws CloneNotSupportedException{
   		return (Student)super.clone();
   	}
   }
   

   5.ioc
   6.动态代理（反射的一种）
   ​ ioc的体现：

servlet：1）创建类继承Servlet
				2）在web.xml中注册servlet	
				<servlet-name>MyServlet</servlet-name>
				<servlet-class>com.bjpowernode.servlet.MyServlet</servlet-class>
				3）Tomcat创建Servlet对象，tomcat也被称为容器

​				tomcat作为容器，包括有servlet对象，listener，filter等

3. ioc的技术实现
   DI是ioc的技术实现
   DI：dependency injection 依赖注入，只需要在程序中提供要使用的对象名称就可以，至于该对象如何在容器内部实现，赋值，查找都由容器内部来实现。

   spring是使用di实现了ioc的功能，spring底层创建对象使用的是反射机制。

第三章 spring创建对象

3.1 构建spring项目

首先想使用spring，你肯定要有spring相关依赖啊，对不对

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>5.3.25</version>
</dependency>

其次，有了spring的依赖后，你想让spring容器来创建对象，那你首先肯定得有类，现在假设你的自定义类有了，是Student，那你得让spring知道他该去哪里构建什么对象对不对？在spring的配置文件里写下需要创建对象的信息。

<bean id="标签，spring根据这个标签找到这一条创建的对象" 
	  class="全限定类名，必须要是具体的实现类，因为spring底层是反射机制"
/>

最后你配置好了怎么用呢？

1.spring创建对象的时机是new容器时，会创建配置文件中所有的对象

ApplicationContext ac = new ClassPathXmlApplicationContext(config);	//config表示spring的配置文件位置
Student stu = (Student)ac.getBean("id");

2. 通过spring提供的接口获取到spring容器中的信息

   //使用spring提供的方法，获取容器中对象的数量
   	int count = ac.getBeanDefinitionCount();
   	//容器中每个对象的名称
   	String[] str = ac.getBeanDefinitionNames();
   

3.2 spring的一些操作

1. 给创建的对象赋值
   基于XML的DI
   基于注解的DI

2. 基于XML的DI：

   1. set注入（设值注入）：spring调用类的set方法（主流）

      包括简单类型的set注入和引用类型的set注入
      	简单类型 value
      	<property name="" value="">
      	引用类型	ref
      	<property name""  ref="其他bean id">
      

   2. 构造注入，spring调用类的有参构造创建对象，在构造方法中完成赋值。

      <bean ......>
      		<constructor-arg name="" value=""/>	name 形参名 value 值
      		<constructor-arg index="" ref=""/>	index 形参位置 ref引用类型值
      </bean>
      

   3. 自动注入，只对引用类型有用
      

3. 多配置文件的优势
   1.每个文件大小比单独一个文件小，效率高
   2.避免多人合作带来的冲突
   如果项目有多个模块，每个模块一个配置文件

4. 多文件分配方式
   1.按功能模块
   2.按类的功能，数据库相关的类可以用一个配置文件，等等。。

5. 包含关系的配置文件

6. 基于注解的DI
   1.通过注解完成java对象的创建，属性赋值
   2.使用注解的步骤

   1. 加入maven依赖spring-context，在加入spring-context的同时，间接加入spring-aop的依赖
      使用注解必须使用spring-aop依赖

   2. 在类中加入spring的注解（多个不同功能的注解）

   3. 在spring的配置文件中，加入一个组件扫描器的标签，说明注解在项目中的位置

      学习的注解：

      @Component
      @Repository
      @Service
      注解用于实现类上，标记当前类是一个service类，加上该注解会将当前类自动注入到spring容器中，
      不需要再在applicationContext.xml文件定义bean了。
      @Controller
      @Value
      @Resource
      @Autowired
      

3.3 spring配置文件标签属性

<bean id="ServiceTest" 对象的自定义名称，spring通过这个id找到你要创建哪个对象

 	  class="org.example.Service.impl.ServiceTest1Impl" 用来定义类的全限定名（包名＋类名）。只有子类Bean不用定义该属性。
 	  
      name="serviceTest1"	用于指定Bean的别名，bean标签的name属性也是不能重复，
      						且id和name属性也不能重复，name标签应该等同于id属性。
      						
      autowire="byName"		用于指定当前Bean的依赖关系的自动注入方式
	      						no:默认值，不进行自动装配
	            				byName:根据属性名自动装配。
	            					   此选项将检查容器并根据名字查找与属性完全一致的bean，
	            					   并将其与属性自动装配
	            				byType值：表示通过class指定的类型来自动装配
	            						  如果存在多个该类型bean，那么抛出异常，
	            						  并指出不能使用byType方式进行自动装配；
	                        			  如果没有找到相匹配的bean，则什么事都不发生，
	                        			  也可以通过设置dependency-check="objects" 让Spring抛出异常。
	            				constructor值：表示使用构造函数的参数进行自动装配(参数的类型匹配)。
	            							  如果容器中没有找到与构造器参数类型一致的bean， 那么抛出异常
	            				autodetect值：表示自动进行选择匹配方式，
	            							 首先进行constructor自动装配，
	            							 若不存在构造方法则使用byType方式进行自动装配；
	                        				 如果发现默认的构造器，那么将使用byType方式，
	                        				 否则采用 constructor。
	  lazy-init="false"	用于指定当前Bean的初始化时间，
	  					若值为true表示在初次调用时才会自动创建实例并初始化，
      					若为false表示在IoC容器创建的时候就会完成创建和初始化。
		      				singleton值：默认值是单例的。
				            prototype值：多例的
				            request值：web项目中spring创建一个bean对象，将对象存到request域中。
				            session值：每次会话请求对应一个bean实例。
				            globalSession：web项目中，应用在prolet环境，
				            			  如果没有prolet环境那么globalSession相当于session。
		            
      init-method="doSomeService" 用于指定当前Bean的初始化方法，
      							  在Bean实例创建好后，首先会调用其指定名称的方法。
      
      destroy-method="doSomeService" 用于指定当前Bean的销毁方法，
      								 在Bean即将被销毁之前会自动调用该属性指定的方法。
      								 
      depends-on="" 用于指定当前Bean的依赖Bean，强制指定的Bean在当前Bean初始化之前先完成初始化。

      scope ="session"Bean的作用范围
	            singleton值： 默认值是单例的。
	            prototype值： 多例的
	            request值：web项目中spring创建一个bean对象，将对象存到request域中。
	            session值：每次会话请求对应一个bean实例。
	            globalSession：web项目中，应用在prolet环境，如果没有prolet环境那么globalSession相当于session。
            
      dependency-check =""用于指定Bean的依赖检查模式，检查依赖关系是否完整，与自动装配合用。
            simple值：表示针对基本类型、字符串、集合进行依赖检查
            object值：表示对引用对象进行依赖检查
            all值：表示对基本类型、字符串、集合、引用对象全部进行依赖检查
            none值：表示不进行任何依赖检查，默认情况
            
      factory-method="" 工厂方法属性，通过该属性，我们可以调用一个指定的静态工厂方法，创建bean实例。
      
      factory-bean=""就是生成bean的工厂对象，factory-bean属性和factory-method属性一起使用，首先要创建生成bean的工厂类和方法。
    >
    <constructor-arg name="" 构造方法形参名
				     index="" 参数位置，第几个参数
				     value="" 参数值
				     ref=""		引用参数值
    />
	<property name=""    用于指定属性的名称，与类中的set方法后方的名称一致
			  value="3"  用于指定该属性的值，用于指定的值是基本类型、字符串类型
			  ref="Student" 用于指定该属性的值，ref后面的值为另一个Bean的id
	/> 
</bean>

第四章 AOP面向切片编程

​ 1.动态代理
​ 动态代理能创建对象，
​ 动态代理创建对象后能实现对象的功能增强
​ 2.动态代理的两种方法：
​ 1.jdk的动态代理，要求目标对象必须实现接口，必须有接口
​ 2.CGLIB动态代理，原理是生成目标类的子类，重写父类方法，实现动态代理，要求可以继承
​ 3.jdk动态代理实现步骤
​ 1.创建目标类，SomeServiceImpl目标类，给它的doSome，doOther增加输出时间，事务。
​ 2.创建InvocationHandler接口的实现类，在这个类实现中给目标方法增加功能
​ 3.使用jdk中的类proxy，创建代理对象。实现创建对象的能力。

InvocationHandler的实现类的运行时间：在通过代理对象执行方法时，会调用执行实现类中的这个invoke（）方法
	pulic class MyInvocationHandler implement InvocationHandler{
		//目标对象
		public Object target;	
		//构造方法，传入需要创建代理类的目标类
		public MyInvocationHandler(Object target){
			this.target = target;
		}

​		@overwrite
​		public Object invoke(Method method,Object proxy,Object[] args) throws Throwable{
​			//通过代理对象执行方法时，会调用这个invoke()方法
​			Object res = null;
​			//功能增强代码
​			ServiceTools.doLog();
​			//执行目标类的方法，通过Method类执行
​			res = method.invoke(target,args);	//会执行目标类的doSome(),doOthers()方法
​			//功能增强代码
​			ServiceTools.doTrans();
​			//目标方法的执行结果
​			return res;

​		}
​	}

4. AOP底层采用的是动态代理模式实现的，采用了两种动态代理：jdk动态代理CGLIB的动态代理
   利用AOP可以对业务逻辑各个部分进行隔离，使得业务逻辑各部分耦合度降低。
   aspect：切面，就是增加的功能
   切面的特点：一般是非业务方法

5. JoinPoint:连接点，连接业务方法和切面的位置。就是某类中的业务方法
   PointCut：切入点，指多个连接点方法的集合。
   目标对象：给哪个类的方法增加功能，这个类就是目标对象
   advice:通知，表示切面功能执行的时间

6. aop的技术实现框架
   1.spring ：spring在内部实现了aop规范，能做aop的工作
   spring主要在事务处理时使用aop
   spring的aop比较笨重，不太常用
   2.aspectJ：一个开源的专门做aop的框架，eclipse做的
   spring中集成了aspectJ框架
   aspectj实现aop有两种方式：
   1.使用xml的配置文件：用来配置全局事务
   2.使用注解，主要使用注解
   aspectj有5个注解

7. 学习aspectj框架的使用
   1）切面执行时间，在规范中被称为advice
   在aspectj中使用注解表示的

   1）@Before
   2）@AfterReturning
   3）@Around
   4）@AfterThrowing
   5）@After
   

8. Aspectj的切入点表达式

   execution(modifiers-pattern? ret-type-pattern
   			  declareing-type-pattern? name-pattern(param-pattern)
   			  throws-pattern)
   			 
   	modifiers-pattern:访问权限，可以省略
   	ret-type-pattern:返回类型
   	declaring-type-pattern:包名，可以省略
   	name-pattern:方法名
   	param-pattern：参数个数，参数名称，参数类型
   	throws-pattern:异常类型，可以省略
   

​ 符号说明：
​ * 0至多个任意字符
​ … 用在方法参数中，表示任意多个参数；用在包名后，表示当前包及其子包路径
​ + 用在类名后，表示当前类及其子类；用在接口后，表示当前接口及其实现类

第五章 把mybatis和spring集成在一起

1.集成mybatis和spring的技术是ioc
	
2.mybatis的使用步骤
	1.定义dao接口，StudentDao
	2.定义mapper文件，StudentDao.xml
	3.定义mybatis的配置文件
	4.创建dao的代理对象，
		StudentDao dao = SqlSession.getMapper(StudentDao.class)
		List<Student> studentList = dao.selectStudent();
	要使用dao对象，需要使用getMapper()方法，
	1.获取SqlSession对象，需要使用SqlSessionFactory的openSession()方法
	2.创建SqlSessionFactory对象，可以通过读取mybatis配置文件.

	InputStream in = Resources.getResourcesAsStream(config);
	SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in)
	SqlSession sqlSession = factory.openSession(true); 

3.需要让spring创建以下对象：
	1.独立的连接池类的对象，使用阿里的druid连接池
	2.SqlSessionFactory对象
	3.创建出dao对象

第六章 spring事务

​ 1.什么是事务
​ 事务：一组sql语句的集合，集合中有多条sql语句，这些sql语句要么都成功，要么都失败。
​ 这些sql语句的执行是一致的，作为一个整体执行。
​ 2.什么时候使用事务
​ 当操作涉及到多个表，或者是多个sql语句的insert，update，delete。需要保证这些语句同时成功或失败。
​ 在java中，事务应该放在哪里？
​ service类的业务方法上，因为业务方法会调用多个dao方法，执行多个sql语句
​

3. jdbc访问数据库，如何处理事务
   jdbc访问数据库，Connection conn; conn.commit();conn.rollback();
   mybatis访问数据库，sqlSession.commit();sqlSesion.rollback();

4. 3中事务处理有何不足
   1）不同数据库访问技术，处理事务的对象方法不同
   2）需要掌握多种数据库中事务的处理逻辑

5. 怎么解决不足
   spring提供了一种处理事务的统一模型，能使用统一的步骤和方式完成多种不同数据库访问技术的事务处理。

6. 处理事务，需要怎么做，做什么
   spring处理事务模型，使用的步骤都是固定的，把事务使用的信息提供给spring就可以了
   1）spring内部提交回滚事务使用的是事务管理器对象，代替完成commit和rollback
   事务管理器是一个接口和他的众多实现类。
   接口：PlatformTransactionManager，定义了事务的重要方法commit，rollback
   实现类：spring把每一种数据库访问技术对应的事务处理类都创建好了
   例如mybatis访问时—spring创建的是DataSourceTransactionManager
   Hibernate访问时—spring创建的是HibernateTransactionManager
   怎么使用：告诉spring用的是什么访问技术
   怎么告诉：在spring的配置文件中使用声明就可以了
   例如：用mybatis访问数据库
   
   2)业务方法需要什么样的事务，需要说明事务的类型
   说明方法需要的事务
   1）事务隔离级别：有4个值，在spring中用常量表示，这些常量均是以ISOLATION_开头
   DEFAULT：采用数据库自身默认的隔离级别，mysql是REPEARABLE_READ；Oracle是READ_COMMITED
   READ_UNCOMMITED:读未提交
   READ_COMMITED：读已提交
   REPEATABLE_READ:可重复读
   SERIALIZABLE：序列化读，串行化
   2）事务超时时间：表示一个方法最长的执行时间，如果方法执行超过了时间，事务就回滚
   单位是秒，整数值，默认是-1，就是没有限制 TIMEOUT_DEFAULT
   3）事物的传播行为：
   处于不同事务中的方法在相互调用时，执行期间事务的维护情况。
   例如A中的doSome()调用B中的doOther()，在调用执行期间事务的维护情况，就称为事务传播行为。
   7个传播行为表示你的业务方法调用时，事务在方法之间是如何使用的。都以PROPAGATION开头
   PROPAGATION_REQUIRED:
   指定的方法必须在事务内执行，若当前存在事务，就加入到当前事务中去；若当前没有事务，则创建一个事务。
   这种传播行为是最常见的，spring默认的事务传播行为。
   PROPAGATION_REQUIRES_NEW
   指定的方法总是会开启一个新事务，如果当前存在事务，则会挂起，直到新事务执行完毕
   PROPAGATION_SUPPORTS
   指定的方法支持事务，可以在事务内运行，但如果没有事务，也可以以非事务方式执行。

​ PROPAGATION_MANDATORY
​ PROPAGATION_NESTED
​ PROPAGATION_NEVER
​ PROPAGATION_NOT_SUPPORTED

7. spring提交事务，回滚事务的时机
   1）当你的业务方法执行成功，没有异常抛出，当方法执行完毕，spring在方法执行后自动提交。
   2）当你的业务方法抛出运行时异常，spring执行回滚，调用事务管理器的rollback。
   运行时异常的定义：RuntimeException和他的子类都是运行时异常，例如NullPointException，NumberFormatException
   3）当业务方法抛出非运行时异常，主要是受查异常时，提交事务。
   受查异常就是在你写代码中必须处理的异常，例如IOException，SQLException

8. 总结spring事务
   1.管理事务的是 事务管理和他的实现类
   2.spring的事务是一个统一模型
   1）指定要使用的事务管理器实现类，使用
   2）指定哪些类，哪些方法需要加入事务的功能
   3）指定方法需要的事务隔离级别，传播行为，超时。

   需要告诉spring，你的项目中类信息，方法的名称，方法的事务传播行为。

9. spring框架中提供的事务处理方案
   1.适合中小项目使用的，注解方案。
   spring框架自己用aop实现给业务方法增加事务的功能，使用@Transactional注解增加事务。
   @Transactional是spring自己的注解，放在public方法的上面，表示当前方法具有事务。
   可以给注解的属性赋值，包括隔离级别，传播行为，异常信息等。
   @Transactional的属性如下：
   propagation：用于事务传播属性，默认Propagation.REQUIRED
   isolation：用于设置事务的隔离级别，默认isolation.default
   readonly：用于设置该方法对数据库的操作是否是只读的。默认为false
   timeout：设置操作与数据库连接的超时时限，默认-1
   rollbackFor：指定需要回滚的异常类，是class数组
   rollbackForClassName：指定需要回滚的异常类类名。类型为String[],
   noRollbackFor:指定不需要回滚的异常类，是class数组
   noRollbackForClassName：指定不需要回滚的异常类类名。类型为String[],
   使用@Transactional的步骤：
   1.需要声明事务管理器对象
   
   2.开启事务注解驱动，告诉spring框架，我要使用注解的方式管理事务。
   spring使用aop机制，创建@Transactional所在的类代理对象，给方法加入事务的功能。
   spring给业务方法加入事务：
   在你的业务方法执行之前，先开启事务，在业务方法之后提交或回滚事务，使用aop环绕通知。
   3.在方法上加入@transactional注解
   2.适合大型项目，有很多的类，方法，需要大量的配置事务，使用aspectj框架功能，在spring配置文件中声明类
   和方法需要的事务。这种方式业务方法和事务配置完全分离。

​ 实现步骤：都是在xml配置文件中实现。
​ 1）要使用的是aspectj框架，需要加入依赖
​ org.springframework
​ spring-aspjects
​ 2）声明事务管理器对象
​
​ 3）声明方法需要的事务类型(配置方法的事务属性【隔离级别，传播行为，超时】)
​ 4）配置aop：指定哪些类要创建代理

第七章 在web项目中使用容器对象

​ 1.javase项目有main方法，可以直接运行创建applicationContext ctx = new ClassPathApplicationContext(config);
​ web项目是在tomcat服务器上运行的。tomcat一启动，项目一直运行。但每发送一次请求就会创建一次容器

  需求：web项目中的容器对象只需要创建一次就够了，把容器对象放入到全局作用域ServletContext中，这样servlet就可以
  		只创建一次。
  实现：使用监听器，当全局作用域对象被创建时，创建容器 存入ServletContext中。
  
  监听器的作用：
  1）创建容器对象,执行ApplicationContext ctx = new ClassPathApplicationContext(config);
  2）把容器对象放入到ServletContext，ServletContext.setAttribute(key,ctx);

  监听器可以自己创建，也可以使用框架中提供好的ContextloaderListener