Spring

这篇Spring文章是基于 狂神说 和 Java3y 两位大佬所写的Spring文章的笔记与总结，仅供个人学习和复习用。欲学习Spring知识推荐前往两位大佬的博客中学习。

Spring简介

Spring是一个轻量级控制反转(IOC)和面向切面(AOP)的容器框架。

• 目的：解决企业应用开发的复杂性。
• 功能：使用基本的JavaBean代替EJB，并提供更多的企业应用功能。
• 范围：任何Java应用。

导包：

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

IOC

本质

控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法。 我们使用面向对象编程，对象的创建与对象之间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，所谓控制反转就是：获得依赖对象的方式反转了。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到零配置的目的。

控制反转是一种通过描述(XML或注解)并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入(Dependency Injection,DI)。

Spring配置

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 http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="MySqlImpl" class="com.kuang.dao.UserMySqlImpl"/>
    <bean id="OracleImpl" class="com.kuang.dao.UserOracleImpl"/>
    <bean id="UserServiceImpl" class="com.kuang.service.UserServiceImpl">
        <!--
          ref: 引用Spring容器中创建好的对象
          value: 具体的值，基本数据类型！
        -->
        <property name="userDao" ref="OracleImpl"/>
    </bean>
</beans>

1.别名

<!--如果添加了别名，我们也可以通过别名获取到这个对象-->
    <alias name="UserServiceImpl" alias="userservice"/>

2.bean的配置

<!--
        id: bean的唯一标识符，也就相当于我们的对象名
        class: bean对象所对应的全限定名：包名+类型
        name: 也是别名，而且name 可以同时取多个别名
    -->
    <bean id="MySqlImpl" class="com.kuang.dao.UserMySqlImpl" name="mySql1 mySql2,mySql3">
        <property name="name" value="mysql数据库"/>
    </bean>

socpe属性

当未设置bean的scope属性时，默认使用的是单例模式。

• 当我们使用Singleton（单例）的时候，从IOC容器获取的对象都是同一个：
  （对象在IOC容器之前就已经创建了）

<bean id="student" class="com.kuang.pojo.Student" scope="singleton">

• 当我们使用prototype（多例）的时候，从IOC容器获取的对象都是不同的：
  （对象在使用的时候才创建）

  <bean id="student" class="com.kuang.pojo.Student" scope="prototype">

  Bean创建细节总结

/**
   * 1) 对象创建： 单例/多例
   *  scope="singleton", 默认值， 即 默认是单例 【service/dao/工具类】
   *  scope="prototype", 多例；        【Action对象】
   * 
   * 2) 什么时候创建?
   *    scope="prototype"  在用到对象的时候，才创建对象。
   *    scope="singleton"  在启动(容器初始化之前)， 就已经创建了bean，且整个应用只有一个。
   * 3)是否延迟创建
   *    lazy-init="false"  默认为false,  不延迟创建，即在启动时候就创建对象
   *    lazy-init="true"   延迟初始化， 在用到对象的时候才创建对象
   *    （只对单例有效）
   * 4) 创建对象之后，初始化/销毁
   *    init-method="init_user"       【对应对象的init_user方法，在对象创建之后执行 】
   *    destroy-method="destroy_user"  【在调用容器对象的destroy方法时候执行，(容器用实现类)】
   */

3.import

• 一般用于团队开发使用，它可以将多个配置文件，导入合并为一个总的。在使用的时候直接使用总的配置文件。

<import resource="beans.xml"/>
<import resource="beans1.xml"/>
<import resource="beans2.xml"/>

依赖注入(Set方式注入)

• 依赖注入：Set注入依赖： bean对象的创建依赖于容器！

注入： bean对象中的所有属性，由容器来注入。

实体类 Student 和 Address

//set get toString 忽略
public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbies;
    private Map<String,String> card;
    private Set<String> games;
    private String wife;
    private Properties info;
}
public class Address {
    private String Address;
}

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 http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="address1" class="com.kuang.pojo.Address">
        <property name="address" value="广州"/>
    </bean>
    <bean id="student" class="com.kuang.pojo.Student">
        <!--普通值注入 value-->
        <property name="name" value="sky23333"/>

        <!--注入对象 bean注入 ref-->
        <property name="address"  ref="address1"/>

        <!--数组注入 array标签 value-->
        <property name="books">
            <array>
                <value>红楼梦</value>
                <value>三国演义</value>
                <value>水浒传</value>
                <value>西游记</value>
            </array>
        </property>

        <!--List list标签 value-->
        <property name="hobbies">
            <list>
                <value>唱歌</value>
                <value>跳舞</value>
                <value>打篮球</value>
                <value>学习</value>
            </list>
        </property>

        <!--Map map标签 entry-->
        <property name="card">
            <map>
                <entry key="id" value="1"/>
                <entry key="phone" value="123456"/>
            </map>
        </property>

        <!--Set value-->
        <property name="games">
            <set>
                <value>王者荣耀</value>
                <value>刺激战场</value>
            </set>
        </property>

        <!--null-->
        <property name="wife">
            <null/>
        </property>

        <!--property propos<prop key>value</prop>-->
        <property name="info">
            <props>
                <prop key="性别">男</prop>
                <prop key="成绩">优秀</prop>
                <prop key="身高">180</prop>
                <prop key="体重">130</prop>
            </props>
        </property>
    </bean>
</beans>

测试类

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Student student = (Student)context.getBean("student");
        System.out.println(student.toString());
    }
}

运行结果：

Student{name='sky23333', 
address=Address{Address='广州'},
books=[红楼梦, 三国演义, 水浒传, 西游记], 
hobbies=[唱歌, 跳舞, 打篮球, 学习], 
card={id=1, phone=123456}, 
games=[王者荣耀, 刺激战场], 
wife='null', 
info={性别=男, 成绩=优秀, 身高=180, 体重=130}}

Bean自动装配

byName和byType

<bean id="cat" class="com.kuang.pojo.Cat"/>
<bean id="dog" class="com.kuang.pojo.Dog"/>
<!--byName  会自动在容器的上下文中查找，和自己对象set方法后面的值对应的Beanid-->
<bean id="people" class="com.kuang.pojo.People" autowire="byName"/>
<!--byType 会自动在容器的上下文中查找，和自己对象属性类型相同的的Bean (缺点 必须保证类型(Class)全局唯一才能装配)-->
<bean id="people" class="com.kuang.pojo.People" autowire="byType"/>

使用注解自动装配

在使用之前需要做如下几个步骤：
1.导入约束： context约束
2.配置注解的支持：context:annotation-config/

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <!--开启注解的支持-->
    <context:annotation-config/>
</beans>

实体类中：

public class People {
    @Autowired
    private Dog dog;

    @Autowired
    private Cat cat;
    private String name;
}

@Autowired

直接在属性上使用，也可以在set方法上使用。

（如果使用@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解@Autowired完成的时候，可以使用@Qualifier(value=’xxx’)去配置@Autowired的使用，指定唯一的bean对象注入）

注解开发

在Spring4之后，要使用注解开发，必须保证aop的包导入了。

org.springframework:spring-aop:5.2.10.RELEASE

使用注解需要导入context约束，增加注解支持！

<context:component-scan base-package=”com.xxx”/>

属性注入

//等价于<bean id="user" class="com.kuang.pojo.User"/>
@Component
public class User {
    @Value("zsky333")//<bean id="user" class="com.kuang.pojo.User" > <property name="name" value="zsky2333"/>  </bean>
    private String name;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

衍生的注解

@Component 有几个衍生注解，我们在web开发中，会按照mvc三层架构分层！

• dao 【@Repository】
• service 【@Service】
• controller 【@Controller】

这四个注解功能都是一样的，都是代表某个类注册到Spring中，装配Bean。

xml与注解

• xml更加万能，适用于任何场合！维护更加方便
• 注解不是自己的类使用不了，维护相对复杂！

我们在使用的过程中，需要注意一个问题：必须让注解生效，就需要开启注解的支持

<!--指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.kuang"/>
    <context:annotation-config/>

使用Java方式配置Spring

通过java来实现不适用Spring的xml配置。

JavaConfig是Spring的一个子项目，在Spring4之后，它成为了一个核心功能！

• 实体类

@Component //@Component 说明这个类被Spring接管了，注册到容器中.
public class User {
    private String name;

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

• 配置类

//@Configuration代表这是一个配置类，相当于bean.xml
@Configuration //通过Spring容器托管，注册到容器中，本来就是一个@Component
@ComponentScan("com.kuang.pojo")
public class MyConfig {
    /**
     * 注册一个Bean，就相当于之前写的bean标签
     * 这个方法的名字相当于bean标签中的id属性
     * 这个方法的返回值，相当于bean标签中的class属性
     * @return
     */
    @Bean
    public User getUser(){
        return new User();
    }
}

• 测试类

public class MyTest {
    public static void main(String[] args) {
        //如果完全使用配置类方式去做，我们就只能通过AnnotationConfig上下文来获取容器，通过配置类的class对象加载
        ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
        User user = (User)context.getBean("user");
        System.out.println(user.getName());
    }

这种纯java的配置方式，在SpringBoot中随处可见。

AOP

代理模式

代理模式是SpringAOP的底层

静态代理

角色分析：

• 抽象角色：一般会使用接口或者抽象类来解决。
• 真实角色：被代理的角色
• 代理角色：代理真实角色，代理真实角色后，一般会做一些附属操作
• 客户：访问代理对象的人

代码步骤：

• 接口

//租房
public interface Rent {
    public void rent();
}

• 真实角色

//房东
public class Host implements Rent{

    public void rent() {
        System.out.println("房东要出租房子");
    }
}

• 代理角色

public class Proxy {
    private Host host;

    public Proxy(){}

    public Proxy(Host host){
        this.host = host;
    }

    public void rent(){
        show();
        host.rent();

    }

    public void show(){
        System.out.println("找中介看房");
    }
}

• 客户端访问代理角色

public class Client {
    public static void main(String[] args) {
        //房东要租房子
        Host host = new Host();
        //代理 中介帮房东租房子，可以进行附属操作
        Proxy proxy = new Proxy(host);
        //客户不用面对房东，通过中介实现需求
        proxy.rent();

    }
}

静态代理模式的好处:

• 可以使真实角色的操作更加纯粹！不用去关注一些公共业务

• 公共业务交给代理角色！实现了业务分工！

• 公共业务发生扩展的时候，方便集中管理！

  缺点：一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低。

动态代理

动态代理和静态代理角色一样

动态代理分为两大类：基于接口动态代理，基于类的动态代理。

• 基于接口——JDK动态代理
• 基于类——cglib

动态代理模式的好处:

• 可以使真实角色的操作更加纯粹！不用去关注一些公共业务

• 公共业务交给代理角色！实现了业务分工！

• 公共业务发生扩展的时候，方便集中管理！

• 一个动态代理类代理的是一个接口，一般是对应的一类业务

• 一个动态代理类可以代理多个类，只要实现了同一个接口即可

  通用动态代理类

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//用这个类自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理接口
    private Object target;

    public void setRent(Object target){
        this.target = target;
    }

    //生成得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    //处理代理实例并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质就是使用反射机制实现！
        Object result = method.invoke(target,args);
        return result;
    }

}

动态代理例子

• 接口

//租房
public interface Rent {
    public void rent();
}

• 真实角色

//房东
public class Host implements Rent{

    public void rent() {
        System.out.println("房东要出租房子");
    }
}

• 代理角色

//用这个类自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理接口
    private Rent rent;

    public void setRent(Rent rent){
        this.rent = rent;
    }

    //生成得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
    }

    //处理代理实例并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        seeHouse();
        //动态代理的本质就是使用反射机制实现！
        Object result = method.invoke(rent,args);
        fare();
        return result;
    }

    public void seeHouse(){
        System.out.println("中介看房子");
    }
    public void fare(){
        System.out.println("收中介费");
    }
}

• 客户端访问代理角色

public class Client {
    public static void main(String[] args) {
        //真实角色
        Host host = new Host();

        //代理角色：现在没有
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //通过调用程序处理角色来处理我们要调用的接口对象！
        pih.setRent(host);

        Rent proxy = (Rent)pih.getProxy();//这里的proxy是动态生成的
        proxy.rent();
    }
}

AOP(面向切面编程)，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

Spring中实现AOP

使用AOP织入，需要导入一个依赖包

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
       <dependency>
           <groupId>org.aspectj</groupId>
           <artifactId>aspectjweaver</artifactId>
           <version>1.9.4</version>
       </dependency>

• 方式一：使用Spring API接口
• 方式二：自定义来实现AOP （主要是切面定义）
• 方式三：使用注解实现AOP

声明式事务

回顾事务

• 把一组业务当作一个业务来做，要么都成功，要么都失败。
• 事务在项目开发中，十分重要，涉及到数据的一致性问题，不能马虎，
• 确保完整性和一致性。

事务ACID原则

• 原子性
• 一致性
• 隔离性
• • 多个业务可能操作同一个资源，防止数据损坏。
• 持久性
• • 事务一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化的写到存储器中。