spring框架文档学习(包会)

spring简介

spring是一个轻量级开源框架，是为了解决企业应用程序开发复杂性创建的

spring目前是JavaEE开发的灵魂框架。他可以简化JavaEE开发,可以非常方便整合其他框架，无侵入的进行功能增强。

spring的核心是控制反转(IOC)和面向切面(AOP)。

IOC控制反转

ioc概念

spring ioc控制反转，对象之间的依赖交给sping来进行管理，避免了强耦合；

ioc使用

（1）导入依赖

导入SpringIOC相关依赖

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

（2）编写实体类

路径自己建立

public class User {
    private String name;

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

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

（3）编写配置文件

在resources目录下创建applicationContext.xml文件，文件名可以任意取。但是建议叫applicationContext。

内容如下：

<?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">
       
    <!--
        classs:配置类的全类名
        id:配置一个唯一标识
        property 相当于给对象中的属性设置一个值！
    -->
    
    <bean id="user" class="com.guohui.pojo.User">
        <property name="name" value="国辉"/>
    </bean>
    
</beans>

（3）创建容器从容器中获取对象并测试

public class MyTest {
    public static void main(String[] args) {
    
        //创建对象
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        //获取对象
        User user = (User) context.getBean("user");
        
        System.out.println(user);
    }
}

ioc三种创建对象方式

····使用无参构造创建对象，默认！
····假设我们要使用有参构造创建对象。

（1）下标赋值

<!--第一种方式：下标赋值    -->
    <bean id="user" class="com.guohui.pojo.User">
        <constructor-arg index="0" value="国辉"/>
    </bean>

（2）类型创建

<!--第二种方式：通过类型的创建，不建议使用    -->
    <bean id="user" class="com.guohui.pojo.User">
        <constructor-arg type="java.lang.String" value="guohui"/>
    </bean>

（3）参数名

<!--第三种方式：直接通过参数名来设置    -->
    <bean id="user" class="com.guohui.pojo.User">
        <constructor-arg name="name" value="国辉"/>
    </bean>

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

DI依赖注入

构造器注入

使用有参构造进行注入

    <bean id="user" class="com.guohui.pojo.User">
        <constructor-arg type="java.lang.String" value="guohui"/>
    </bean>

Set方法注入

依赖：bean对象的创建依赖于容器！
注入：bean对象中的所有属性,由注入器来注入

<!--
    classs:配置类的全类名
    id:配置一个唯一标识
    property 相当于给对象中的属性设置一个值！
-->
    <bean id="user" class="com.guohui.pojo.User">
        <property name="name" value="国辉"/>
    </bean>

(c,p)命名注入

注意点：p命名和c命名空间不能直接使用，需要导入xml约束！

       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"

了解就行了，不推荐使用！

bean的作用域

单例模式（Spring默认机制）scope=“singleton”
原型模式：每次从容器中get的时候，都会产生一个新对象！scope=“prototype”

其余的request、session、application、这些只能在web开发中使用到！

bean的自动装配

自动装配是spring满足bean依赖的一种方式！

Spring会在上下文中自动寻找，并自动给bean装配属性！

在Spring中有三种装配的方式：

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

ByName自动装配

        <!--
        byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的bean id！
            -->
<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>

使用注解实现自动装配

@Autowired注解

注解开发准备工作
​ 如果要使用注解开发必须要开启组件扫描，这样加了注解的类才会被识别出来。Spring才能去解析其中的注解。

   导入约束
   xmlns:context="http://www.springframework.org/schema/context"

xml
<!--启动组件扫描，指定对应扫描的包路径，该包及其子包下所有的类都会被扫描，加载包含指定注解的类-->
<context:component-scan base-package="com.guohui"/>

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
     <!--  启动组件扫描-->
    <context:component-scan base-package="com.guohui"/>
    
    <bean id="cat" class="com.guohui.pojo.Cat"/>
    <bean id="dog" class="com.guohui.pojo.Dog"/>
    <bean id="people" class="com.guohui.pojo.People">
    </bean>

</beans>

@Autowired注解
直接在属性上使用即可！

public class People {
    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;

    private String name;

    @Override
    public String toString() {
        return "People{" +
                "cat=" + cat +
                ", dog=" + dog +
                ", name='" + name + '\'' +
                '}';
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public String getName() {
        return name;
    }

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

Spring注解开发

bean

@Component//相当于 <bean id ="user" class="com.guohui.dao.User"/>

public class User {

    //相当于  <property name="name" value="guohui"/>
    @Value("guohui")
    
    public String name;
    //相当于  <property name="name" value="666666"/>
    
    @Value("666666")
    public String pwd;
    
}

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

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

自动装配

- @Autowired：自动装配通过类型，名字。如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value = "xxx")去配置。
- @Nullable 字段标记了了这个注解，说明这个字段可以为null;
- @Resource：自动装配通过名字，类型。

脱离spring的xml配置，纯注解开发

@Component
public class User {
    private String name;

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

    public User() {

    }

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

    public String getName() {
        return name;
    }


    public User(String name) {
        this.name = name;
    }
}

配置文件applicationContext.xml

// 这个也会Spring容器托管，注册到容器中，因为它本来就是一个@Component
// @Configuration代表这是一个配置类，就和我们之前看的applicationContext.xml文件
@Configuration
@ComponentScan("com.guohui.pojo")//启动注解扫描
@Import(GuoConfig.class)//引入多个@Configuration相当于引入多个applicationContext.xml文件
public class GuoConfig {

    //注册一个bean。相当于applicationContext.xml文件里的bean标签
    //这个方法的名字就是bean中的id属性
    //这个方法返回的值相当于，bean标签中的class属性
    @Bean
    public User getUser(){
        return new User();
    }
}

测试类

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

AOP底层:代理模式

静态代理

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

代码案例
想恋爱的男孩

//单生狗要找对象
public class boy {
    public static void main(String[] args) {

        //男生恋爱找媒人就行了，媒人就相当于代理模式
        Proxy proxy = new Proxy();

        proxy.like();
       //媒人帮忙必收好，a方法收钱，b方法蹭饭
        proxy.a();
        proxy.b();
    }
}

女人

//女人----要恋爱
public class girl implements like{

    @Override
    public void like() {
        System.out.println("女孩要恋爱！！！");
    }
}

成双结对-恋爱

//恋爱-在一起
public interface like {
    public void like();
}

媒人-(代理模式)

//媒人
public class Proxy implements like {
    private girl girl;

    public Proxy() {
    }

    public com.guohui.demo_01.girl getGirl() {
        return girl;
    }

    public void setGirl(com.guohui.demo_01.girl girl) {
        this.girl = girl;
    }

    @Override
    public void like() {
        System.out.println("帮女孩恋爱");
    }

    public void a() {
        System.out.println("收中介费用");
    }

    public void b() {
        System.out.println("吃席");
    }
}

代理模式的好处：

1、代理模式能将代理对象与真实被调用的目标对象分离。
2、一定程度上降低了系统的耦合度，扩展性好。
3、可以起到保护目标对象的作用。
4、可以对目标对象的功能增强。

代理模式的坏处：

 1、代理模式会造成系统设计中类的数量增加。
 2、在客户端和目标对象增加一个代理对象，会造成请求处理速度变慢。
 3、增加了系统的复杂度。

动态代理

动态代理底层是反射

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写好的！
动态代理分为两大类：基于接口的动态代理，基于类的动态代理

动态代理基于接口：jdk动态代理
需要了解两个类：Proxy：代理；InvocationHandler：调用处理程序。

动态代理的好处：

可以使真实角色的操作更加纯粹！不用去关注一些公共的业务 公共角色就交给代理角色！实现了业务的分工！ 公共业务发生扩展的时候，方便集中管理！
一个动态代理类代理的是一个接口，一般就是对应的一类业务 一个动态代理类可以代理多个类，只要是实现了同一个接口即可！

Aop概念

Spring 面向切面编程（Aop）
面向切面的编程，或AOP， 是一种编程技术，对业务逻辑中的各个部分切割隔离，使耦合度降到最低，不仅增加了开发效率，还增强了系统的重用性和可维护性。

Spring实现Aop

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

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

使用Spring的API接口

使用注解简单

自定义来实现AOP

使用注解简单

注解实现AOP

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

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

在service包下，定义UserService业务接口

public interface UserService {
    void a();
    void b();
    void c();
    void d();
}

UserServiceImpl实现类

public class UserServiceImpl implements UserService{
    @Override
    public void a() {
        System.out.println("a方法");
    }

    @Override
    public void b() {
        System.out.println("b方法");
    }

    @Override
    public void c() {
        System.out.println("c方法");
    }

    @Override
    public void d() {
        System.out.println("d方法");
    }
}

在diy包下定义注解实现的AnnotationPointCut增强类

//声明式事务！
@Aspect//标注这个类是一个切面
public class Anoot { 

    @Before("execution(* com.guohui.service.UserServiceImpl.*(..))")//切入点
    public void beforeo() {
        System.out.println("=====方法执行前-切入-  =====");
    }

    @After("execution(* com.guohui.service.UserServiceImpl.*(..))")//切入点
    public void after() {
        System.out.println("====方法执行后-切入-  ====");
    }

}

在Spring配置文件中，注册bean，并增加支持注解的配置。

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

    <!--配置bean-->
    <bean id="userservice" class="com.guohui.service.UserServiceImpl"/>
    <bean id="log" class="com.guohui.log.Log"/>
    <bean id="afterLog" class="com.guohui.log.AfterLog"/>

    <!--配置aop:需要导入aop约束-->
    <bean id="anno" class="com.guohui.diy.Anoot"/>
    <aop:aspectj-autoproxy/>
</beans>

测试

public class demo {
    public static void main(String[] args) {
        
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        UserService userService = (UserService) context.getBean("userservice");
        
        userService.a();
    }
}

看到此文档的人，希望这篇文档能给你们带来价值！！！