spring课堂笔记

spring课程：

第一章 概念
spring是一个比较大的框架，比mybatis大的多。功能也比较多。更复杂了。
spring可以访问数据库，可以管理事务，可以做web开发。

spring是一个轻量的java框架，核心技术是ioc，aop。spring的主要的作用是解耦和。
实现对象之间，模块之间的解耦和， 让项目开发增加功能，修改代码对其他部分影响下，
可以实现一些代理的重复使用。

spring是开源的框架，官网是spring.io

=========================================================
第二章 ioc

ioc（Inversion of Control）：控制反转，是一个理论，一个思想。知道开发人员如何使用java对象的。
把对象的创建，属性赋值，对象和对象之间的关系这些都放到代码之外容器中管理。 换句话就是在容器中
管理对象，对象的属性，对象之间的依赖关系。 容器是一个角色，现在是使用spring作为容器。
spring这个容器中放到的都是java对象， 在容器中每个对象都有名字，通过名字使用这个对象。

依赖关系：classA中使用了classB的属性或者方法， 叫做classA依赖classB
public class SomeService{
private UserDao userDao = new UserDao();

public void addUser(User user){
   userDao.insertUser(user);
}

}

控制：控制对象的创建，属性赋值，对象关系的管理。
反转：把对象的创建，赋值都交给代码之外的容器，把开发人员管理对象的权限交给了容器。
容器代替开发人员的工作。
正转：现在开发人员在代码中，使用new创建对象，调用set方法给属性赋值，这是正转。 开发人员在代码中
决定对象的创建，使用。

控制反转举个例子：就是你要吃饭：1.自己做；2点外卖。
1.自己做，就是正转的方式。
2.点外卖（反转），方便，指定一个菜名，由餐厅准备食材，由厨师按步骤做菜。 之后给你的就是一个做好的饭菜。

ioc理论的技术实现：
1.DL( Dependency Lookup ),容器提供回调接口和上下文环境给组件
2.DI( Dependency Injection ),你只需要提供要使用的对象名称就可以，
至于这个对象在容器中怎么创建，赋值，容器中查找对象都不用你管。

spring框架作为容器的角色，使用的就是di的技术，意味着你使用名称就能从spring中获取对象，使用。
spring底层用的什么技术，创建对象，给属性赋值呢 ？ 反射。

概念的关系：
ioc是理论–di实现技术的名词–spring使用了di的技术（反射）
在有些书籍上， 把di就等同于ioc。

如果你现在使用了spring，项目应该怎么做呢， 怎么使用对象 ？
将对象创建在容器里，使用的时候直接拿，不在自己new对象。

现在学过的知识中，有无ioc的体现呢？

servlet是ioc的体现：
怎么使用servlet：
1.定义类继承HttpServlet, 这个类是你定义的。
2.在web.xml注册这个servlet，使用注册servlet

在这个过程中，你没有创建过servlet对象吧 ，没有new HelloServlet();
servlet对象是tomcat服务器创建的，tomcat就是一个容器，tomcat中存放的是
各种servlet对象，listener对象，filter对象

---

第一个spring项目：
spring的配置文件需要使用约束文件（扩展名是xsd的），作用是控制你写的配置文件里面可以出现的标签
标签的属性，已经他的值，顺序等等。 spring使用的配置文件是xml格式的， 里面是固定的语法，不能随意写。

spring配置文件的基本格式：

<?xml version="1.0" encoding="UTF-8"?>

<!-- bean definitions here -->

spring配置文件的根是beans,在beans里面有很多的bean， bean就表示java对象。
spring中每一个bean，就是一个java对象。 我们java对象叫做bean

------------------------------------------------------------------------------------------’
spring框架给java对象的属性赋值。给属性赋值也叫做di（依赖注入）
spring给属性赋值分类：
1.set注入也叫做设值注入
2.构造注入，使用有参数构造方法赋值。

以上两种分类可以使用的语法格式：
1.使用xml配置文件中的标签和属性实现
2.使用注解实现

什么对象应该定义在spring配置文件中：
1.service对象
2.dao对象
3.工具类对象

哪些对象不适合交给spring呢？
1.实体类
2.用户提交的参数
3.servlet， filter，listener （tomcat创建管理）

spring的大型项目，推荐使用多个配置文件，怎么划分配置文件
1.按模块分（功能分）：把相关功能的类写在一个配置文件。
2.按类组织层次：service类放在一个文件，dao文件放在一个文件，事务的配置放在一个文件

spring中组织多个配置文件，使用最多是包含关系的配置文件，是说一个主文件（总文件），内部
包含了其他多个文件的路径。 然后再使用文件时，只需要加载读取总文件就可以了。
包含关系使用的标签是
关键字“classpath:”表示类路径，也就是class文件所在的目录

---

使用注解完成对象创建和属性赋值，使用DI的功能
学习的注解有：
1.@Component @Respository @Service @Controller
2.@Value
3.@Autowired @Resource

使用注解的步骤：
1.确认的你项目依赖有spring-aop
2.在类中加入注解
3.在spring的配置文件加入 context:component-scan basePackage=“注解所在的包名”

---

ioc:能干什么
1.创建对象
2.给属性赋值
3.管理对象的依赖关系，实现对象之间的解耦和。

ioc实现解耦合：service和dao对象之间的耦合， spring作为容器，主要是管理service，dao，工具类等对象。

==============================================================================
第三章aop 面向切面编程

aop是基于动态代理的， aop实际就是动态代理。

1）动态代理： 在程序执行过程中，创建对象。 这个对象可以调用目标方法的功能，还能增强功能
2）动态代理作用： 1.功能增强。2.调用目标方法，可以控制目标方法是否能访问。
3）动态代理的实现方式：
1.jdk动态代理：使用jdk中的java.lang.reflect包中的类实现代理对象的创建。底层使用的是反射机制。
他要求目标类必须实现接口，有接口才能使用jdk动态代理。

2.cglib动态代理：使用第三方工具库， 叫做cglib。原理是继承。通过cgilb库在内部创建类的子类，
这个子类就是动态创建的代理。 cglib使用限制，目标类不能是final， 方法也不能是final的。

4）动态代理项目和不用动态代理的区别

aop:是基于动态代理的，就是动态代理的。 aop是把动态的实现进行了规范化，看做是一个理论。规范。
aop就所以动态的实现步骤，实现的方式，能做什么功能都定义好实现步骤，流程。

AOP（Aspect Orient Programming），面向切面编程。面向切面编程是从动态角度考虑程序运行过程。

Aspect:切面，切面就是给业务方法增加的功能， 像日志，事务，统计时间，权限验证都可以使用切面。
Orient：面向
Programming：编程

怎么面向切面编程？
1.分析出项目中哪些功能是切面，哪些功能可以作为切面使用。
切面的功能一般都是非业务功能， 这些切面功能可以独立使用。

2.确定切面执行的时间，方法之前，方法之后

3.确定切面在哪个位置执行，doSome有切面功能，doOther没有

切面Aspect有三个要素
1.切面的功能是什么
2.切面的执行时间
3.切面执行位置。

面向切面编程作用？优点？

1. 减少代码的重复
2. 让你专注业务功能的开发。
3. 实现业务功能和非业务的解耦和。
4. 切面功能的复用

---

AOP中的术语：
1.Aspect：切面， 就是要给业务方法增加的功能，常见的切面是日志，事务，权限检查。
2.连接点（JoinPoint ）：业务方法（一个方法），这个方法是切面功能加入的位置。 连接的是业务方法和切面功能。
切面是在这个方法执行时，增加功能。
3.切入点（Pointcut ）：是多个连接点组合，包含了一个多个方法。 表示切面加入的位置

4.目标对象（Target ）：给那个类加功能，这个类就是目标类

5.通知（Advice ）：包含了切面的要素， 通知也叫增强，表示切面功能执行的时间

一个切面功能的实现：需要有三个要素
1.切面功能本身，要做什么， 输出日志， 提交事务。（一些代码，方法）
2.切面的执行位置，在哪个方法执行时，加入切面的功能
3.切面的执行时间，在方法之前，方法之后呢

AOP的实现框架
1.spring框架，实现了aop，内部是使用接口表示Advice。 spring的实现aop比较笨重。开发人员用的少
2.aspectj框架：一个独立的框架，可以和spring一起使用。 在spring中已经提供了对aspectj框架的支持。
可以拿来就用。 aspectj专门做aop的， 功能强大。使用灵活。

aspectj：是eclipse基金会中的开源项目。 使用注解和xml配置文件两种方式实现aop，以注解为主，配置简单了解。

使用aspectj框架：
aspectj框架有自己的语法，表示切面的执行位置， 切面的执行时间

1。切面执行时间，使用的注解和xml中的标签。
注解有：
@Before：前置通知， 在目标方法之前执行的切面功能
@AfterReturning:后置通知：在目标方法之后执行的切面功能
@Around:环绕通知：在目标方法前和后都能增强功能的
@AfrerThrowing:异常通知：在目标方法抛出异常时执行的。
@After：最终通知，总是会执行的切面

2。切面的执行位置：使用的切入点表达式
execution(方法的定义)

使用aspectj实现aop的功能
1.在pom.xml文件加入aspectj的依赖
spring-aspects

2.目标类，定义了业务方法，给这些方法要切面的功能

3.创建一个普通类，作为切面类使用。
1）在类的上面加入@Aspect
2）在类中定义方法， 实现切面的功能
在方法的上面加入通知注解，例如@Before(value=“切入点表达式”)

4。创建spring 的配置，通过spring和aspectj一起，创建代理对象
1）声明目标对象
2）声明切面对象
3）声明自动代理生成器，是一个标签，来自aspectj框架中的功能。
生成目标对象代理。asepctj会修改内存中的目标对象， 变成代理。
目标对象就是代理对象。

5.测试：从spring的容器中获取目标（代理）：通过代理执行目标方法，实现
执行目标方法时，切面的功能也执行，给目标方法增加功能

---

开发人员做某个aop的功能， 使用aspectj的注解。 除了注解，aspectj还可以使用xml配置文件实现aop功能。
这里xml配置文件的作用和注解完成的是一样的功能。但形式不一样。

配置文件的方式大家做理解的方式就可以了。我们后边做叫事务。 事务他的实现可以aspectj的aop。
并且是在配置文件中实现的事务控制。

===========================================================================================
第四章： spring和mybatis的集成， 把spring和mybatis放在一起使用。 通过spring使用mybatis对象，访问数据库。

回顾mybatis的使用
1.两种配置文件：mybatis主配置文件 ； mapper文件（写sql语句）
2.使用mybatis访问数据库， 需要一些对象。
1）需要有 xxxDao对象 ， 例如StudentDao对象
StudentDao dao = sqlSession.getMapper(StudentDao.class);

    使用SqlSession对象，创建了dao对象
    
 
 2）需要创建SqlSession对象
    SqlSession sqlSession = MyBatisUtils.getSession();
    
    在工具类中，使用sqlSession = factory.openSession();
    创建SqlSession对象，需要使用SqlSessionFactory对象
    
 3）SqlSessionFactory
    SqlSessionFactory factory = new SqlSessionFactoryBuilder().build("mybatis.xml");
    创建SqlSessionFactory需要使用主配置文件的信息

创建对象，spring很方便，可以让spring作为容器创建对象，使用Ioc。
比如创建Date，用spring的语法

还有一个问题，mybatis的dataSource,是mybatis自己内部的数据库连接池。
大型项目使用比较有名的连接池 DruidDataSource（阿里公司出品的连接池）
也让spring创建 DruidDataSource对象， 作为连接数据库的连接池对象。

=================================================================================
第五章：事务
spring完成工作都是模板， 事务的处理也是模板。 模板长什么样 ？
spring的事务是一个高度的抽象，这个抽象就是模板。 这样你使用不同的数据库，不同访问数据库框架
就能使用一套模板，适应不同的数据库，不同框架的事务处理。

数据库有很多：mysql ，sql server ， db2 , oracle
访问数据库的技术： jdbc， mybatis， spring中的JdbcTemplate, hibernate, jpa
访问数据库的技术不同，处理事务的方法也不同。

mybatis处理事务： SqlSession.commit(); SqlSession.rollback();
hibernate处理事务： Session.commit(); Session.rollback();

不用spring 处理事务：
开发人员张三----mybatis—使用mybatis的SqlSession提交，回滚事务
开发人员张三----hibernate—使用hibernate的Session提交，回滚事务
开发人员张三----jpa—使用jpa的Manager的管理Session提交，回滚事务

使用spring处理事务

开发人员张三--------spring（commit,rollback）---使用mybatis的SqlSession提交，回滚事务
开发人员张三--------spring（commit,rollback）---hibernate---使用hibernate的Session提交，回滚事务
开发人员张三--------spring（commit,rollback）---使用jpa的Manager的管理Session提交，回滚事务

spring中处理事务涉及两个接口
1.事务管理器PlatformTransactionManager接口
在接口中的定义了你的项目中可以使用的事务方法
1）事务提交 commit();
2) 事务回滚 rollback();

接口有众多的实现类：
每一种数据库的访问技术或者框架都有一个PlatformTransactionManager接口的实现类

1）DataSourceTransactionManager: 使用jdbc，mybatis时的事务管理器PlatformTransactionManager的实现类。
  调用你在项目执行insert后，提交事务---spring---找DataSourceTransactionManager---SqlSession.commit();
  
2) HiberanteTransactionManager:使用hibernate框架访问数据库时，使用这个实现类

事务管理器PlatformTransactionManager的实现类spring都已经写好了， 你在项目中拿来用就可以了
你只需要在spring的配置文件中，声明事务管理器实现类就可以了。例如

属性设置

2.第二个接口：事务定义接口TransactionDefinition
TransactionDefinition接口中使用常量，定义了事务控制的一些值。
控制事务，主要有 1）事务的隔离级别，2）事务的传播行为，3）事务的超时时间

TransactionDefinition接口中定义了多种隔离级别的值
TransactionDefinition接口中定义了多种传播行为的值
TransactionDefinition接口中定义了事务超时的值

1）隔离级别
➢ DEFAULT：采用 DB 默认的事务隔离级别。MySql 的默认为 REPEATABLE_READ； Oracle默认为 READ_COMMITTED。
➢ READ_UNCOMMITTED：读未提交。未解决任何并发问题。
➢ READ_COMMITTED：读已提交。解决脏读，存在不可重复读与幻读。
➢ REPEATABLE_READ：可重复读。解决脏读、不可重复读，存在幻读
➢ SERIALIZABLE：串行化。不存在并发问题。  

2）事务的传播行为：spring中新的内容。
传播行为是指方法之间调用过程中，事务是如何传递和使用的，管理的。
事务在方法之间如何使用就是传播行为。

   给谁设置事务呢？ 业务方法设置事务，也就是service类中的方法。
   一个方法就是一个事务， 方法的全部内容应该在一个事务中执行。
   
   比如： public class StudentService{
            //给业务方法设置事务
            public void saveStudent(){
               studentDao.insertStudent();
               schoolDao.update();
               teacherDao.select()
            
            }
            
            
            public void doStudent(){
                 saveStudent()
            }
        }
        
        
    PROPAGATION_REQUIRED 
	PROPAGATION_REQUIRES_NEW
	PROPAGATION_SUPPORTS
	以上三个会用
	
	PROPAGATION_MANDATORY
	PROPAGATION_NESTED
	PROPAGATION_NEVER
	PROPAGATION_NOT_SUPPORTED
	
	
	说明传播行为
	PROPAGATION_REQUIRED：业务方法需要事务，这是spring的默认值
	PROPAGATION_REQUIRES_NEW：业务方法执行时，需要你的事务
	PROPAGATION_SUPPORTS：支持事务，没有事务方法正常执行。

3）事务的超时时间
一个方法最长的执行时间，时间以秒为单位。 如果方法的在指定的时间内没有执行完毕
spring是回滚事务。

---

事务的提交回滚
spring的规定，当你的业务方法没有异常时，方法执行完毕，事务提交。
如果你的方法执行过程中抛出了运行时异常，spring回滚事务。
如果你的方法执行过程中抛出的是受查异常，spring默认是提交事务， 可以手工设置成回滚事务。

什么是运行时异常： RuntimeException和他的子类都是运行时异常，
例如NullPointException , NumberFormatException

什么是受查异常：在编译java代码时，必须处理的异常，不处理代码编译不过去。
例如SQLException ,IOException

---

事务的总结：
1.确定使用的事务管理器， 你使用jdbc或者mybatis访问数据库， 那么管理器就是DataSourceTransactionManager
需要在spring容器中，创建事务管理器对象， 让spring能使用这个对象，做事务的内部commit， rollback

属性设置

2.在你的业务方法上面设置隔离级别（5），传播行为（7），超时（1）

---

spring中处理事务的模板
1.使用spring框架自己的注解@Transactional：简单，方便，快捷
2.大型项目使用的aspectj在xml配置文件中，使用aop的思想，设置每个方法的事务。

spring和aspectj两个框架，spring自己能做事务，aspectj也能做事务。

准备事务的环境
做一个模拟电商购买商品的流程， 1，用户下订单，生成订单记录；2.扣减库存。
购买商品对应一个方法，叫做buy方法，这个方法内部有两个数据库操作， 创建订单， 修改库存。
buy需要在事务内执行。 保证两个数据库的操作所以一直， 都成功，或者都失败。

1.事务控制第一种处理方式： 使用spring框架自己的注解@Transtional.
实现步骤：
1）在spring的配置文件中，声明事务管理器
开启事务注解驱动tx:annotation-driven

2. 在service实现类的public方法的上面加入@Transactional注解，设置他的属性

2.事务处理的第二种方式 ，是asepctj框架在xml配置文件中，
全局配置各个业务方法的事务属性（隔离级别，传播行为，超时）

源代码不需要修改，就可以实现事务的不同设置。

通过配置文件可以一目了然知道项目整体的事务管理。

实现步骤:
1.要使用asepctj框架，pom.xml加入 spring-aspects依赖
2.修改spring配置文件
1）声明目标对象（service对象）
2）声明业务方法需要的事务属性（隔离级别，传播行为，超时）
3）声明切入点表达式，指定那些包中的类他们要参与事务

=======================================================================================
第六章： 在web项目中如何使用spring容器对象
重点： 在web项目如何把spring容器对象创建出来

首先，普通的java项目，执行是main开始的，我们是在main方法中，创建spring容器对象，执行方法调用
public static void main(String[] args) {
String config= “applicationContext.xml”;
ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
SomeService someService = (SomeService) ctx.getBean(“service”);
someService.doSome();
}

web项目不是通过main方法执行的， 不能在main中创建容器了。需要换一个方式把spring的容器对象创建出来。
web项目启动后，一直运行呀。用户的操作发送给servlet，servlet调用方法。
web项目运行后，spring这个容器对象应该一直存在。

---

web项目我们希望容器对象创建一次， 而且能够全局使用。
解决方式：把容器的创建放在监听器中， 并且把创建好的容器对象放入到ServletContext中。

spring框架中有一个可用监听器ContextLoaderListener. 这个监听器完成容器创建一次，并放入到ServletContext

怎么使用监听器：
1.加入spring-web依赖， 这个依赖中有ContextLoaderListener类
2.在web.xml注册注册监听器

---

ContextLoaderListener源代码

WebApplicationContext 容器：
定义public interface WebApplicationContext extends ApplicationContext

spring中容器定义：
1.普通的java项目，使用ApplicationContext
2.web项目，又定义一种容器 WebApplicationContext

1. 实现了ServletContextListener接口
   初始方法
   public void contextInitialized(ServletContextEvent event) {
   this.initWebApplicationContext(event.getServletContext());
   }

2. 成员变量： private WebApplicationContext context;
   public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {

   1）if (this.context == null) {
   //创建容器对象， 相当于 WebApplicationContext ctx = new ClassPathXmlApplicationContext(“spring.xml”)
   this.context = this.createWebApplicationContext(servletContext);
   }

   2）把容器对象放入到ServletContext中
   servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);

   key ：WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE 常量字符串
   WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE

   }