目录

1、spring概述

1、简介

2、依赖

3、优点

4、Spring Boot与Spring Cloud

2、IOC理论推导

2.1、IOC的原型

2.2、IOC本质

2.3、IOC创建对象的方式

3、Spring配置

3.1、别名

3.2、bean配置

3.3、import

4、依赖注入（DI）

4.1、依赖注入：属于set注入！

4.2、注入

4.3、p命名和c命名注入

4.4、Bean的作用域

5、Bean的自动装配

5.1、手动配置如下

5.2、byName

5.3、byType

6、使用注解开发

6.1、说明

6.2、Bean的实现

6.3、属性注入

6.4、衍生注解

6.5、自动装配注解（作用参考5）

6.6、作用域

6.7、小结

7、基于Java类进行配置

8、代理模式

8.1、静态代理：

8.2、动态代理

9、AOP

9.1、准备工作导包：

9.2、使用Spring实现Aop

9.3、自定义类实现动态代理

9.4、注解实现

10、整合mybatis

1、导入相关jar包

2、MyBatis-Spring        

11、Spring中的事务管理

1、spring概述

1、简介

    Spring : 春天 --->给软件行业带来了春天
    2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。
    2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。
    很难想象Rod Johnson的学历 , 他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。
    Spring理念 : 使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术
    官网 : http://spring.io/
    官方下载地址 : https://repo.spring.io/libs-release-local/org/springframework/spring/
    GitHub : https://github.com/spring-projects

2、依赖

在maven工程下的pom.xml中导入spring
 

    org.springframework
    spring-webmvc
    5.1.10.RELEASE

3、优点

Spring是一个开源的免费的框架
Spring是一个轻量级的，非入侵式的框架
控制反转（IOC） ，面向切面编程（AOP）
支持事务的处理，对框架整合的支持
总结：Spring是一个轻量级的控制反转（IOC）和面向切面编程（AOP）Spring是一个开源的免费的框架

4、Spring Boot与Spring Cloud

        Spring Boot 是 Spring 的一套快速配置脚手架，可以基于Spring Boot 快速开发单个微服务;
        Spring Cloud是基于Spring Boot实现的；
        Spring Boot专注于快速、方便集成的单个微服务个体，Spring Cloud关注全局的服务治理框架；
        Spring Boot使用了约束优于配置的理念，很多集成方案已经帮你选择好了，能不配置就不配置 , Spring Cloud很大的一部分是基于Spring Boot来实现，Spring Boot可以离开Spring Cloud独立使用开发项目，但是Spring Cloud离不开Spring Boot，属于依赖的关系。
        SpringBoot在SpringClound中起到了承上启下的作用，如果你要学习SpringCloud必须要学习SpringBoot。

2、IOC理论推导

2.1、IOC的原型

        代码分为dao层和service层，之后web层的处理都会使用service层，如果一个dao接口类有多个实现类在service层设置一个方法，该方法用于设置某个接口dao的具体实现类，可以实现不触碰dao层的情况下随意切换不同的dao层实现类
        

public class UserServiceImpl implements UserService {
    private UserDao userDao;
    public void setUserDao(UserDao userDao){
        this.userDao=userDao;
    }
}

        使用该方法，把主动权交给了调用者，程序不用去管怎么创建,怎么实现了。它只负责提供一个接口。
        这种思想,从本质上解决了问题,我们程序员不再去管理对象的创建了,更多的去关注业务的实现。耦合性大大降低。这也就是IOC的原型 !

2.2、IOC本质

控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，

IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。
IoC,一句话搞定 : 对象由Spring 来创建 , 管理 , 装配 !

控制反转 :
            控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的。
            反转 : 程序本身不创建对象 , 而变成被动的接收对象 .
依赖注入 : 就是利用set方法来进行注入的.
IOC是一种编程思想，由主动的编程变成被动的接收

2.3、IOC创建对象的方式

        1、通过无参构造方法来创建
           

2、通过有参构造方法来创建

 在配置文件加载的时候。其中管理的对象都已经初始化了！

3、Spring配置

3.1、别名

alias为bean设置别名,可以设置多个别名，name值填写对应的id值
 

3.2、bean配置

3.3、import

         假设项目中有多个bean.xml，通过import可以将多个bean.xml导入到一个总的bean.xml。使用时使用总的配置文件即可。
 

4、依赖注入（DI）

三种注入方式：构造器注入、set注入、其他注入。

4.1、依赖注入：属于set注入！

        依赖 : 指Bean对象的创建依赖于容器。Bean对象的依赖资源。
       注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配。

4.2、注入

1、常量注入

2、Bean注入
          注意点：这里的值是一个引用，ref

3、数组注入

  
      
          西游记
          红楼梦
          水浒传
      
  

4、List注入

   
      唱歌
      画画
      跳舞
   

5、Map注入

6、set注入

    
        LOL
        BOB
        COC
    

7、Null注入

8、Properties注入

private Properties info;

    
        20190604
        男
        小明
    

4.3、p命名和c命名注入

1、p命名：

导入约束：xmlns:p="http://www.springframework.org/schema/p"
可以直接使用p:属性名="" 给属性赋值。属于set注入，必须有属性的set方法！

2、c命名

导入约束： xmlns:c="http://www.springframework.org/schema/c"
可以直接使用c:属性名="" 给属性赋值。属于构造器注入，必须有有参构造器！

4.4、Bean的作用域

1、单例模式：Singleton（默认）

        Spring IoC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。

2、原型模式：Prototype

         表示一个bean定义对应多个对象实例。Prototype作用域的bean会导致在每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的bean实例。

3、request、session、application 、这些只能在web开发中使用到

3.1、Request
                当一个bean的作用域为Request，表示在一次HTTP请求中，一个bean定义对应一个实例；即每个HTTP请求都会有各自的bean实例，它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

         针对每次HTTP请求，Spring容器会根据loginAction bean的定义创建一个全新的LoginAction bean实例，且该loginAction bean实例仅在当前HTTP request内有效，因此可以根据需要放心的更改所建实例的内部状态，而其他请求中根据loginAction bean定义创建的实例，将不会看到这些特定于某个请求的状态变化。当处理请求结束，request作用域的bean实例将被销毁。

3.2、Session：
                当一个bean的作用域为Session，表示在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

        针对某个HTTP Session，Spring容器会根据userPreferences bean定义创建一个全新的userPreferences bean实例，且该userPreferences bean仅在当前HTTP Session内有效。与request作用域一样，可以根据需要放心的更改所创建实例的内部状态，而别的HTTP Session中根据userPreferences创建的实例，将不会看到这些特定于某个HTTP Session的状态变化。当HTTP Session最终被废弃的时候，在该HTTP Session作用域内的bean也会被废弃掉。

5、Bean的自动装配

5.1、手动配置如下

手动配置cat和dog有点麻烦，可以使用bean自动装配

5.2、byName

需要保证所有beanid唯一，并且这个bean需要和注入的属性的set方法值一致
会自动在上下文中查找，和自己对象set方法后面的值对应的beanid。例：setCat和cat
修改bean配置，增加一个属性  autowire="byName"

5.3、byType

首先需要保证：同一类型的对象，在spring容器中唯一，否则会报不唯一的异常。
其次，需要在Spring中注册，没有id值也可以获取到

6、使用注解开发

6.1、说明

jdk1.5开始支持注解，spring2.5开始全面支持注解。
在spring4之后，想要使用注解形式，必须得要引入aop的包
在配置文件当中，还得要引入一个context约束
 

6.2、Bean的实现

我们之前都是使用 bean 的标签进行bean注入，但是实际开发中，我们一般都会使用注解！
1、配置扫描哪些包下的注解

2、在指定包下编写类，增加注解

@Component("user")
// 相当于配置文件中 
public class User {
    public String name = "秦疆";
}

6.3、属性注入

使用注解注入属性
1、可以不用提供set方法，直接在直接名上添加@value("值")

@Value("秦疆")// 相当于配置文件中 
public String name;

2、如果提供了set方法，在set方法上添加@value("值");

public String name;
@Value("秦疆")
public void setName(String name) {
     this.name = name;
}

6.4、衍生注解

为了更好的进行分层，Spring可以使用其它三个注解，功能一样,都是放在容器中注册。
@Component三个衍生注解:
@Controller：web层
@Service：service层
@Repository：dao层

6.5、自动装配注解（作用参考5）

1、@Autowired
     @Autowired是按类型自动转配的，不支持id匹配，需要导入aop约束。
     可以直接在属性上使用即可（可以没有Set方法）！也可以在set方式上使用！
     @Autowired(required=false)说明：false，对象可以为null；true，对象必须存对象，不能为null。

2、@Qualifier
     @Autowired是根据类型自动装配的，加上@Qualifier则可以根据byName的方式自动装配
     @Qualifier不能单独使用。
     例：

@Autowired
@Qualifier(value = "cat2")
private Cat cat;
@Autowired
@Qualifier(value = "dog2")
private Dog dog;

3、@Resource
     指定一个name：自动装配

@Resource(name="cat1")
private Cat cat;

小结：@Resource和@Autowired的区别：
               都是自动装配，可以放在属性字段上
              @Autowired通过byType的方式实现，要求这个对象必须存在
              @Resource如有指定的name属性，先按该属性进行byName方式查找装配；其次再进行默认的byName方式进行装配；如果以上都不成功，则按byType的方式自动装配。都不成功，则报异常。

6.6、作用域

@scope
singleton：默认的，Spring会采用单例模式创建这个对象。关闭工厂 ，所有的对象都会销毁。
prototype：多例模式。关闭工厂 ，所有的对象不会销毁。内部的垃圾回收机制会回收 

@Scope("prototype")
public class User {
      public String name;
}

6.7、小结

XML与注解比较
            XML可以适用任何场景 ，维护方便
            注解不是自己提供的类使用不了，开发简单方便，维护相对复杂

xml与注解整合开发（推荐最佳实践）：
            xml管理Bean
            注解完成属性注入
            使用过程中，只需要注意一个问题：必须让注解生效就需要开启注解支持。可以不用扫描，扫描是为了类上的注解
          作用：
            进行注解驱动注册，从而使注解生效
            用于激活那些已经在spring容器里注册过的bean上面的注解，也就是显示的向Spring注册
            如果不扫描包，就需要手动配置bean
            如果不加注解驱动，则注入的值为null！

7、基于Java类进行配置

     JavaConfig 原来是 Spring 的一个子项目，它通过 Java 类的方式提供 Bean 的定义信息
    在 Spring4 的版本， JavaConfig 已正式成为 Spring4 的核心功能 。
1、实体类

public class Dog {
     public void shout(){
         System.out.println("wang");
     }
}

2、创建一个配置包config，创建一个配置类

@Configuration  //代表这是一个配置类
public class MyConfig {
      @Bean //通过方法注册一个bean，这里的返回值就Bean的类型，方法名就是bean的id！
      public Dog dog(){
           return new Dog();
      }
}

3、测试：

public static void main(String[] args){
        // 获取ApplicationContext，拿到配置包
            ApplicationContext context =new AnnotationConfigApplicationContext(MyConfig.class);
        //getBean获取对应id的bean
            Dog dog= context.getBean("dog", Dog.class);
            dog.shout();
}

多个配置类可以创建一个总类，在类名上使用@import(MyConfig2.class)，导入合并其他配置类，类似于配置文件中的 inculde 标签
    纯java的配置方式在SpringBoot中随处可见

8、代理模式

        为什么要学习代理模式，因为AOP的底层机制就是动态代理！
    代理模式：
        静态代理
        动态代理

8.1、静态代理：

静态代理角色分析
            抽象角色 : 一般使用接口或者抽象类来实现
            真实角色 : 被代理的角色
            代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作
            客户  :  使用代理角色来进行一些操作。
静态代理的好处:
            可以使得我们的真实角色更加纯粹。不再去关注一些公共的事情。
            公共的业务由代理来完成。实现了业务的分工，公共业务发生扩展时变得更加集中和方便。
 缺点 :
            类多了,多了代理类,工作量变大了。开发效率降低。
我们想要静态代理的好处，又不想要静态代理的缺点，所以就有了动态代理!

8.2、动态代理

动态代理的角色和静态代理的一样。
        动态代理的代理类是动态生成的。静态代理的代理类是我们提前写好的
动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理
            基于接口的动态代理----JDK动态代理
            基于类的动态代理--cglib
            现在用的比较多的是 javasist 来生成动态代理 . 百度一下javasist
这里使用JDK的原生代码来实现，其余的道理都是一样的！
        1、 编写一个通用的动态代理实现的类！所有的代理对象设置为Object：

import org.springframework.cglib.proxy.InvocationHandler;
import org.springframework.cglib.proxy.Proxy;
import java.lang.reflect.Method;
//动态代理工具类
public class ProxyInvocationHandler implements InvocationHandler {
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }
    //生成代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }
    // proxy : 代理类
    // method : 代理类的调用处理程序的方法对象.
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }
    public void log(String methodName){
        System.out.println("执行了"+methodName+"方法");
    }
}

        使用：

public static void main(String[] args) {
        //真实角色
        Host host = new Host();
        //代理实例的调用处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(host); //将真实角色放置进去！
        //动态代理代理的是接口
        Rent proxy = (Rent)pih.getProxy(); //动态生成对应的代理类！
        proxy.rent();
    }

动态代理的好处
            静态代理有的它都有，静态代理没有的，它也有！
            可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
            公共的业务由代理来完成 . 实现了业务的分工 ,
            公共业务发生扩展时变得更加集中和方便 .
            一个动态代理 , 一般代理某一类业务
            一个动态代理可以代理多个类，代理的是接口！

9、AOP

9.1、准备工作导包：

        导入包
 

   org.aspectj
   aspectjweaver
   1.9.4

9.2、使用Spring实现Aop

(1)、编写接口和实现类

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();

}
public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("add");
    }
    @Override
    public void delete() {
        System.out.println("delete");
    }
    @Override
    public void update() {
        System.out.println("update");
    }
    @Override
    public void select() {
        System.out.println("select");
    }
}

(2)、编写前置增强类

public class log implements MethodBeforeAdvice {

    @Override
    public void before(Method method, Object[] objects, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+ method.getName()+"方法执行了");
    }
}

(3)、去Spring中注册，并实现aop切入实现

(4)、测试

public class UserServiceImplTest {

    @Test
    public void add() {
    //ClassPathXmlApplicationContext获取spring中注册的bean
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans1.xml");
        //动态代理代理的是接口
        UserService userService =(UserService) context.getBean("userService");
        userService.add();
    }
}

输出：service.UserServiceImpl的add方法执行了

        add

9.3、自定义类实现动态代理

(1)、编写接口和实现类，代码如上9.2

(2)、编写自定义类DiyPointCut

public class DiyPointCut {
    public void before(){
        System.out.println("before方法");
    }
    public void after(){
        System.out.println("after方法");
    }
}

(3)、配置文件

(4)、测试

public class UserServiceImplTest {

     @Test
     public void add() {
         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans1.xml");
         //动态代理代理的是接口
         UserService userService =(UserService) context.getBean("userService");
         userService.add();
     }
 }

输出：before方法
                  add
                  after方法

9.4、注解实现

(1)、编写接口和实现类，代码如上9.2

(2)、编写一个注解实现的增强类

@Aspect//标注这个类是一个切面
public class AnnotationPointCut {
    @Before("execution(* service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("方法执行前");
    }
    @After("execution(* service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("方法执行后");
    }
    //环绕增强中可以给定一个参数，代表我们要获取处理切入的点
    @Around("execution(* service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        jp.proceed();//执行代理类的方法
        System.out.println("环绕后");
    }
}

(3)、配置文件

(4)、测试add方法，代码如上
            输出：
                环绕前
                方法执行前
                add
                环绕后
                方法执行后

10、整合mybatis

1、导入相关jar包

junit

   junit
   junit
   4.12


mybatis

   org.mybatis
   mybatis
   3.5.2


mysql-connector-java

   mysql
   mysql-connector-java
   5.1.47


spring相关

   org.springframework
   spring-webmvc
   5.1.10.RELEASE


   org.springframework
   spring-jdbc
   5.1.10.RELEASE


aspectJ AOP 织入器


   org.aspectj
   aspectjweaver
   1.9.4


mybatis-spring整合包 【重点】

   org.mybatis
   mybatis-spring
   2.0.2


配置Maven静态资源过滤问题！

   
       
           src/main/java
           
               ***.xml
           
           true
       
   

2、MyBatis-Spring        

2.1、MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。

2.2、MyBatis-Spring 需要以下版本：
            MyBatis-Spring     MyBatis    Spring框架   Spring Batch   Java
            2.0                    3.5+       5.0+       4.0+           Java 8+
            1.3                    3.4+       3.2.2+      2.1+            Java 6+

2.3、如果使用 Maven 作为构建工具，仅需要在 pom.xml 中加入以下代码即可：

   org.mybatis
   mybatis-spring
   2.0.2

2.4、合并之前，我们有完整的dao层和service层
        主要是通过spring-dao.xml具体配置替代mybatis-config核心配置文件

        ①、编写数据源配置，替代mybatis-config.xml中环境配置

        ②、sqlSessionFactory,内部可绑定mybatis配置文件

        ③、sqlSessionTemplate，与②一起，创建出sqlSession对象，替代创建sqlSession工具类

        ④、获取sqlSession:

        方式一：编写接口实现类UserMapperImpl中定义一个私有属性SqlSessionTemplate sqlSession;

public class UserMapperImpl implements UserMapper {
   private SqlSessionTemplate sqlSession;
    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }
    @Override
    public List query() {
        return sqlSession.getMapper(UserMapper.class).query();
    }
}

        在spring中注册并给sqlSession赋值 

        方式二：编写接口实现类UserMapperImpl继承SqlSessionDaoSupport，该父类可以直接使用getSqlSession获取sqlSession

public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
    @Override
    public List query() {
        return getSqlSession().getMapper(UserMapper.class).query();
    }
}

                在spring中注册，该方法可以省略③，SqlSessionDaoSupport类中需要给sqlSessionFactory赋值

        ⑤、测试

@Test
public void query() {
    //ClassPathXmlApplicationContext用于获取spring配置文件中注册的bean
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
    UserService userService =(UserService) context.getBean("UserService");
    userService.query();
}

11、Spring中的事务管理

        Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。

1、编程式事务管理
        将事务管理代码嵌到业务方法中来控制事务的提交和回滚
        缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码

2、声明式事务管理
        一般情况下比编程式事务好用。
        将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
        将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。

3、Spring声明事务

3.1、导入aop和tx约束

xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd

3.2、配置声明事务

3.3、结合AOP实现事务的织入

3.4、配置事务切入