Spring5

Spring

官网：https://spring.io/projects/spring-framework

5.2.0官网：https://docs.spring.io/spring/docs/5.2.0.RELEASE/spring-framework-reference/core.html#beans-collection-elements

官方下载地址：https://repo.spring.io/ui/native/release/org/springframework/spring

GitHub：https://github.com/spring-projects/spring-framework

需要的依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.9</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.9</version>
</dependency>

Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架！

IOC

IOC的本质

• 控制反转Ioc（Inversion of Control），是一种设计思想，DI（依赖注入）是实现IoC的一种方法
  控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式
• IOC是一种变成思想，由主动的编程编程被动的接收

控制反转：

• 控制：谁来控制对象的创建，传统的应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的。
• 反转：程序本身不创建对象，而变成被动的接收对象。
• 依赖注入：就是利用set方法来进行注入的

Spring配置

别名

<!--别名，如果添加了别名，我们也可以使用别名获取到这个对象-->
<alias name="user" alias="userNew"/>

Bean的配置

<!--
    id：bean的唯一标识符，也就是相当于我们学的对象名
    class：bean对象所对应的全限定名：包名+类型
    name：也是别名，而且name可以同时取多个别名
-->
<bean id="user" class="com.kuang.pojo.User" name="u2,u3">
    <property name="name" value="西部开源"/>
</bean>

import

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

DI依赖注入

构造器注入

1.下标赋值

<!--第一种，下标赋值！-->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg index="0" value="空洞骑士"/>
</bean>

2.类型

<!--第二种方式：通过类型创建，不建议使用！基本数据类型可以直接写，引用收据类型要写全限定名-->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg type="java.lang.String" value="饥荒"/>
</bean>

3.参数名

<!--第三种，直接通过参数名来设置-->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg name="name" value="深海迷航"/>
</bean>

总结：在配置文件加载的时候，容器中管理的对象就已经初始化了！

Set方式注入【重点】

真实测试对象

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String,String> card;
    private Set<String> games;
    private String wife;
    private Properties info;
}

复杂类型

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

完善注入信息

<?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="address" class="com.kuang.pojo.Address">
        <property name="address" value="雅安"/>
    </bean>

    <bean id="student" class="com.kuang.pojo.Student">
        <!--第一种，普通值注入，value-->
        <property name="name" value="武昌"/>

        <!--第二种，Bean注入，ref-->
        <property name="address" ref="address"/>

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

        <!--list-->
        <property name="hobbys">
            <list>
                <value>听歌</value>
                <value>敲代码</value>
                <value>看电影</value>
            </list>
        </property>

        <!--Map-->
        <property name="card">
            <map>
                <entry key="身份证" value="1111111111114654153"/>
                <entry key="银行卡" value="4685154545"/>
            </map>
        </property>

        <!--Set-->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>COC</value>
                <value>BOB</value>
            </set>
        </property>

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

        <!--Properties-->
        <property name="info">
            <props>
                <prop key="driver">562841</prop>
                <prop key="url">男</prop>
                <prop key="username">小明</prop>
                <prop key="password">156132156</prop>
            </props>
        </property>
    </bean>
</beans>

测试类

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

p命令空间或者c命令空间进行注入

需要导入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"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--p命名空间注入，可以直接注入属性的值：property-->
    <bean id="user" class="com.kuang.pojo.User" p:name="秦疆" p:age="18"/>

    <!--c命名空间注入，通过构造器注入：counstruct-args-->
    <bean id="user2" class="com.kuang.pojo.User" c:name="白起" c:age="500"/>
</beans>

bean的作用域

单例模式（Spring默认机制）

<bean id="user2" class="com.kuang.pojo.User" c:name="白起" c:age="500" scope="singleton"/>

原型模式：每次从容器中get的时候，都会产生一个新对象！

<bean id="user2" class="com.kuang.pojo.User" c:name="白起" c:age="500" scope="prototype"/>

Bean的自动装配

ByName自动装配

<!--
    byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid！
-->
<bean id="people" class="com.kuang.pojo.People" autowire="byName">
    <property name="name" value="亚当"/>
</bean>

ByType自动装配

<!--
    byType：会自动在容器上下文中查找，和自己对象属性类型相同的bean！
-->
<bean id="people" class="com.kuang.pojo.People" autowire="byType">
    <property name="name" value="亚当"/>
</bean>

小结：

• byName的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致！
• bytype的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致！

使用注解实现自动装配

要使用注解须知：
​ 1.导入约束
​ 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>

@Autowired
直接在属性上使用即可！也可以在set方式上使用！

使用Autowired我们可以不用编写Set方法了，前提是你这个自动装配的属性在IOC（Spring）容器中存在，且符合名字byname!

public class People {
    //如果显示的定义了Autowired的required的属性为false，说明这个对象可以为null，否则不允许为空
    @Autowired(required = false)
    private Cat cat;
    @Autowired
    private Dog dog;
    private String name;
}

@Nullable	字段标记了这个注解，说明这个字段可以为null;

如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候、我们可以使用**@Qualifier(value = “xxx”)**去配置@Autowired的使用，制定一个唯一的bean对象注入！

public class People {
   
    @Autowired
    @Qualifier(value = "cat502")
    private Cat cat;
   
    @Autowired
    private Dog dog;
    private String name;
}

@Resource

public class People {
    
    @Resource(name="cat502")
    private Cat cat;
   
    @Autowired
    private Dog dog;
}

小结：
@Resource和@Autowired的区别

• 都是用来自动装配的，都可以放在属性字段上
• @Autowired通过byType的方式实现，而且必须要求这个对象存在！【常用】
• @Resource默认通过byname的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下，就报错！【常用】
• 执行顺序不同：@Autowired通过byType的方式实现.

使用注解开发

@Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层
dao【@Repository】
service【@Service】
controller【@Controller】
这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean

作用域

@Component
@Scope("prototype")
public class User {
    
    //相当于<property name="name" value="xingtian"/>
    @Value("xingtian")
    public String name;
}

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

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

使用java的方式配置Spring

实体类

package com.kuang.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;

//这里这个注解的意思，就是说明这个类配Spring接管了，注册到了容器中
@Controller
public class User {
    private String name;

    public String getName() {
        return name;
    }

    @Value("生姜")//属性注入值
    public void setName(String name) {
        this.name = name;
    }

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

配置文件

package com.kuang.config;

import com.kuang.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

//这个也会Spring容器托管，注册到容器中，因为他本来就是一个@Component
//@Configuration代表这一个配置类，就和我们之前看的beans.xml一样
@Configuration
@ComponentScan("com.kuang.pojo")
@Import(KuangConfig2.class)
public class KuangConfig {

    //注册一个bean,就相当于我们之前写的一个bean标签
    //这个方法的名字，就相当于bean标签中的id属性
    //这个方法的返回值，就相当于bean标签中的class属性
    @Bean
    public User getUser(){
        return new User();
    }
}

测试类

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

AOP代理模式

什么是AOP

• AOP意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护和一种技术。
• AOP是OOP的延续，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

Aop在Spring中的作用

提供声明式事务，允许用户自定义切面

• 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部份，就是横切关注点。如日志，安全，缓存，事务等等…
• 切面（ASPECT）：横切关注点 被模块化的特殊对象。即，他是一个类
• 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
• 目标（Target）：被通知对象。
• 代理（Proxy）：向目标对象应用通知之后创建的对象。
• 切入点（PointCut）：切面通知执行的“地点”的定义。
• 连接点（JoinPoint）：与切入点匹配的执行点。

SpringAOP中，通过Advicce定义横切逻辑，Spring中支持5种类型的Adive

• 前置通知：org.spirngframework.aop.MethodBeforeAdvice
  –在目标方法执行后实施增强
• 后置通知：org.springframework.aop.AfterReturningAdvice
  –在目标方法执行前实施增强
• 环绕通知：org.aopalliance.intercept.MethodInterceptor
  –在目标方法执行前后实施增强
• 异常抛出通知：org.springframework.aop.ThrowsAdvice
  –在方法抛出异常后实施增强
• 引介通知：org.springframework.aop.IntroductionInterceptor
  –在目标类中添加一些i新的方法和属性。

即AOP在不改变原有代码的情况下，去增加新的功能。

使用Spring实现Aop

【重点】使用AOP织入，需要导入一个依赖包！

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version>
</dependency>

方式一：使用Spring的API接口

方式二：自定义来实现AOP

方式三：使用注解实现！