spring太强了！两万多字干货超详细讲解

Designer 小郑

发布于 2023-08-01 10:18:14

3870

发布于 2023-08-01 10:18:14

本文原创首发CSDN，本文链接https://blog.csdn.net/qq_41464123/article/details/108118680 ，作者博客https://blog.csdn.net/qq_41464123 ，转载请带上本链接，谢谢配合。

一、第一个Spring程序

1.1 spring简介

spring：春天，给软件行业带来春天！
spring理念：使现有的技术更加易用，是一个粘合剂，整合了现有的技术框架
spring是一个轻量级的开源免费框架
核心：控制反转（IOC），面向切面编程（AOP）
支持对事务的支持，支持整合其他框架 Spring是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架。

spring官方文档： https://spring.io/projects/spring-framework#learn

maven官网：https://mvnrepository.com/

1.2 环境配置

软件版本

jdk 11.0.6
maven 3.6.2 阿里云
idea 2019.3

idea新建项目配置

需要注意以下几点：

选择创建maven新项目，删除src目录，创建子module
在 File | Settings | Build, Execution, Deployment | Build Tools | Maven 中，配置maven
在 File | Settings | Build, Execution, Deployment | Compiler | Java Compiler 中，设置发行版本为 11
File | Settings | Editor | File Encodings，编码改为UTF-8
在File | Project Setting | Modules 中，将版本设置为11

所需依赖

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.8.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.2.8.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.4</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.0</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.2</version>
    </dependency>
</dependencies>

jdk发型版本配置

如果不配置，运行测试方法时，可能会报“不支持发行版本5”错误

<properties>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
</properties>

所需过滤器

过滤器的作用，是在程序编译时，将xml、properties等静态配置文件也加入 target 包中，否则程序无法读取到xml文件

<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

1.3 编写实体类

User类有两个变量，分别是姓名name和年龄age

类上方的三个注解均在lombok包中

@Data 是用来自动生成set和get方法

@AllArgsConstructor是用来自动生成全部参数的构造方法

@NoArgsConstructor是用来自动生成无参构造方法

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int age;
}

1.4 编写配置文件

<?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"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="user" class="zwz.pojo.User">
        <!-- property相当于给某个变量设置一个值-->
        <property name="name" value="ZWZ"/>
        <property name="age" value="18"/>
    </bean>
</beans>

1.5 测试

先是用传统的方法new一个对象

@Test
public void testtTradition(){
    User user = new User("ZWZ",18);
    System.out.println(user);
}

接着用spring的方式从容器获取一个对象

@Test
public void testSpring(){
    // ApplicationContext Spring上下文对象 | ClassPathXmlApplicationContext 从配置文件中去取
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    // 从容器中取出user对象
    User user = (User) context.getBean("user");
    System.out.println(user);
}

都可以得到相同的运行结果

User(name=ZWZ, age=18)

Process finished with exit code 0

二、IOC 控制反转

2.1传统开发

我们就以**张三想找一个女朋友谈恋爱**为例，结合Java代码，说明spring控制反转和传统开发的区别

web开发后端的层次，从上到下可以分为：Controller（控制器层）、Service（业务逻辑层）、Dao（数据持久层）

谈恋爱接口(Dao层)

这是一个Dao层的接口，描述谈恋爱这一个抽象性行为

public interface LoveDao {
    // 谈恋爱的mapper层接口
    void talkLove();
}

女朋友一号(Dao层实现1)

这是接口的第一个实现，是活灵活现的女朋友

public class LoveDaoImpl1 implements LoveDao {
    @Override
    public void talkLove() {
        System.out.println("女朋友1号和你谈恋爱了!");
    }
}

女朋友二号(Dao层实现2)

这是接口的第二个实现，是活灵活现的女朋友

public class LoveDaoImpl2 implements LoveDao{
    @Override
    public void talkLove() {
        System.out.println("女朋友2号和你谈恋爱了!");
    }
}

女朋友三号(Dao层实现3)

这是接口的第三个实现，是活灵活现的女朋友

public class LoveDaoImpl3 implements LoveDao{
    @Override
    public void talkLove() {
        System.out.println("女朋友3号和你谈恋爱了!");
    }
}

谈恋爱接口(Service层)

这是业务逻辑层的接口，和Dao层一样，是一个抽象性接口

public interface LoveService {
    // 谈恋爱的Service层接口
    void talkLove();
}

谈恋爱实现(Service层)

业务逻辑层调用Dao层的方法，完善业务逻辑层接口的具体实现

如果你选择和女朋友一号谈恋爱，那么…

public class LoveServiceImpl implements LoveService {

    private LoveDao loveDao = new LoveDaoImpl1();
    @Override
    public void talkLove() {
        loveDao.talkLove();
    }
}

测试

@Test
public void testTradition(){
    LoveService loveService = new LoveServiceImpl();
    loveService.talkLove();
}

女朋友1号和你谈恋爱了!

Process finished with exit code 0

如果张三的**需求改变了**，他只想和女朋友二号谈恋爱

那么，我们就**必须修改service层的实现类**

private LoveDao loveDao = new LoveDaoImpl2();

女朋友2号和你谈恋爱了!

Process finished with exit code 0

该程序适应不了需求的变更，需求变了要更改源代码，这是万万不行的！
如何解决？如何让程序不动，让客户端去改变？这就需要控制反转

2.2 IOC控制反转实现

首先，Dao层的接口、Dao层的实现类、Service层的接口不改动，我们只改service实现类和测试方法

谈恋爱实现(Service层)

原有代码直接new出一个Dao层实现，现在我们使用构造器，将Dao层实现类的选择权交给用户，从而实现了控制反转

public class LoveServiceImpl implements LoveService {

    // 传统开发代码
    // private LoveDao loveDao = new LoveDaoImpl1();
    
    // IOC控制反转    LoveDao的选择,放权给用户
    private LoveDao loveDao;

    public LoveServiceImpl(LoveDao loveDao) {
        this.loveDao = loveDao;
    }

    @Override
    public void talkLove() {
        loveDao.talkLove();
    }
}

测试

张三如果想和一号女朋友谈恋爱

@Test
public void testIoc(){
    // 用户需求发生改变，没有改动内部代码
    LoveServiceImpl loveService = new LoveServiceImpl(new LoveDaoImpl1());
    loveService.talkLove();
}

输出

女朋友1号和你谈恋爱了!

Process finished with exit code 0

如果他跟女朋友二号谈恋爱，只需要更改测试方法

@Test
public void testIoc(){
    // 用户需求发生改变，没有改动内部代码
    LoveServiceImpl loveService = new LoveServiceImpl(new LoveDaoImpl2());
    loveService.talkLove();
}

输出

女朋友2号和你谈恋爱了!

Process finished with exit code 0

通过 UserServiceImpl 的构造器，对UserDao进行动态注入，用户可以自己选择需要使用的UserDao的实现类，从而灵活变动

在传统开发中，需求变更需要修改源代码，如果系统代码量大，修改会非常麻烦，牵一发而动全身！
在传统开发中，对象创建在程序中实现；控制反转之后，程序变成了被动接受对象！
控制反转是一种设计思想，让第三方去管理对象的创建和获取。在spring中实现控制反转是IOC容器，实现方法是依赖注入DI

本文原创首发CSDN，本文链接https://blog.csdn.net/qq_41464123/article/details/108118680，作者博客https://blog.csdn.net/qq_41464123，转载请带上本链接，谢谢配合。

三、DI 依赖注入

3.1 概念

在第一个Spring程序中已经体验了，传统赋值和依赖注入的区别

传统赋值

User user = new User("ZWZ",18);

依赖注入

在容器中配置bean,并注入值

<bean id="user" class="zwz.pojo.User">
    <!-- property相当于给某个变量设置一个值-->
    <property name="name" value="ZWZ"/>
    <property name="age" value="18"/>
</bean>

在容器中取出对象

// ApplicationContext Spring上下文对象 | ClassPathXmlApplicationContext 从配置文件中去取
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
// 从容器中取出user对象
User user = (User) context.getBean("user");

两种方式,都可以得到相同的运行结果

User(name=ZWZ, age=18)

Process finished with exit code 0

3.2 根据属性名注入（推荐）

实体类User

该实体类有各种各样的类型，我们尝试对这些复杂数据类型进行注入

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String,String> card;
    private Set<String> games;
    private Properties info;
    private String girlFriend;
}

XML注入

一共八种数据类型，分别加以注入

<!--propertyNameAddress  根据属性名注入的address-->
<!--singleton 单例模式 prototype原型模式-->
<bean id="address" class="zwz.pojo.Address" scope="singleton">
    <property name="address" value="浙江宁波"/>
</bean>
<bean id="user" class="zwz.pojo.User">
    <!--        第一种 普通值注入-->
    <property name="name" value="ZWZ"></property>

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

    <!--        第三种 数组-->
    <property name="books">
        <array>
            <value>Java程序设计</value>
            <value>JavaScript程序设计</value>
            <value>Python程序设计</value>
        </array>
    </property>

    <!--        第四种 List-->
    <property name="hobbys">
        <list>
            <value>敲代码</value>
            <value>听歌</value>
            <value>看小说</value>
        </list>
    </property>

    <!--        第五种 Map-->
    <property name="card">
        <map>
            <entry key="card01" value="卡片1"></entry>
            <entry key="card02" value="卡片2"></entry>
            <entry key="card03" value="卡片3"></entry>
        </map>
    </property>

    <!--        第六种 Set-->
    <property name="games">
        <set>
            <value>QQ飞车手游</value>
            <value>DNF</value>
            <value>敲代码</value>
        </set>
    </property>

    <!--        第七种 空值-->
    <property name="girlFriend">
        <null></null>
    </property>

    <!--        第八种 配置-->
    <property name="info">
        <props>
            <prop key="id">0413170337</prop>
            <prop key="tel">17857054388</prop>
        </props>
    </property>
</bean>

测试

@Test
public void testPropertyName() {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    User user = (User) context.getBean("user");
    System.out.println(user);
}

可以看出，八种数据类型，都已经成功注入到对象中

Student{
name='ZWZ'
, address=Address(address=浙江宁波)
, books=[Java程序设计, JavaScript程序设计, Python程序设计]
, hobbys=[敲代码, 听歌, 看小说]
, card={card01=卡片1, card02=卡片2, card03=卡片3}
, games=[QQ飞车手游, DNF, 敲代码]
, info={tel=17857054388, id=0413170337}
, girlFriend='null'}

Process finished with exit code 0

3.3 根据构造器下标注入

@AllArgsConstructor 注解在之间提到过，是生成全部参数的构造方法

我们可以通过构造器的参数，实现值注入

比如对于构造器0号下标的bookName，注入Java程序设计…

实体类Book

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Book {
    private String bookName;
    private int pageNum;
}

XML注入

<bean id="bookIndex" class="zwz.pojo.Book">
    <constructor-arg index="0" value="Java程序设计"/>
    <constructor-arg index="1" value="66"/>
</bean>

测试

    @Test
    public void testConstructorIndex() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Book book = (Book) context.getBean("bookIndex");
        System.out.println(book);
    }

Book(bookName=Java程序设计, pageNum=66)

Process finished with exit code 0

3.4 根据构造器数据类型注入

@AllArgsConstructor 注解在之间提到过，是生成全部参数的构造方法

我们可以通过构造器的参数类型，实现值注入

比如对于构造器的String类型变量bookName，注入Java程序设计…

当然构造器**不同参数的数据类型必须不一致，否则会出错**，所以这个注入方式说实话没什么用…

### 实体类Book

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Book {
    private String bookName;
    private int pageNum;
}

XML注入

<bean id="bookType" class="zwz.pojo.Book">
    <constructor-arg type="java.lang.String" value="Java程序设计"/>
    <constructor-arg type="int" value="66"/>
</bean>

测试

@Test
public void testConstructorType() {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    Book book = (Book) context.getBean("bookType");
    System.out.println(book);
}

Book(bookName=Java程序设计, pageNum=66)

Process finished with exit code 0

3.5 C / P 命名空间注入

c命名空间注入或者p命名空间注入，分别利用变量名称和构造器下标进行值注入，和之前的没有本质性的区别

XML属性名注入、Java注解最为常用，而C/P命名空间注入一般不会去使用…

实体类Book

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Book {
    private String bookName;
    private int pageNum;
}

XML注入

<bean id="cBook" class="zwz.pojo.Book" c:_0="Java程序设计" c:_1="66"/>

<bean id="pBook" class="zwz.pojo.Book" p:bookName="Java程序设计" p:pageNum="66"/>

测试

@Test
public void testC() {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    Book book = (Book) context.getBean("cBook");
    System.out.println(book);
}

@Test
public void testP() {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    Book book = (Book) context.getBean("pBook");
    System.out.println(book);
}

输出相同

Book(bookName=Java程序设计, pageNum=66)

Process finished with exit code 0

3.6 单例/原型模式

XML配置

singleton 为单例模式，从容器中多次获取bean，bean相同

prototype为原型模式，从容器中多次获取bean，bean不同

<bean id="singletonBook" class="zwz.pojo.Book" scope="singleton">
    <property name="bookName" value="Java程序设计"/>
    <property name="pageNum" value="66"/>
</bean>

<bean id="prototypeBook" class="zwz.pojo.Book" scope="prototype">
    <property name="bookName" value="Java程序设计"/>
    <property name="pageNum" value="66"/>
</bean>

测试

@Test
public void testScope(){
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    Book book1 = (Book) context.getBean("singletonBook");
    Book book2 = (Book) context.getBean("singletonBook");
    System.out.println("singletonBook: " + (book1 == book2));

    Book book3 = (Book) context.getBean("prototypeBook");
    Book book4 = (Book) context.getBean("prototypeBook");
    System.out.println("prototypeBook: " + (book3 == book4));
}

``` singletonBook: true prototypeBook: false ```

3.7 自动装配

自动装配的意思是，假设有两个实体Bean A、B

如果A中包含B，且B已经配置在容器中，那么A可以通过自动装配，将B自动装配注入

当然自动装配只对引用变量生效，对于int、String不支持

实体类BookUser

定义一个包含Book的实体类BookUser

@Data
@AllArgsConstructor
@NoArgsConstructor
public class BookUser {
    Book book;
}

### XML配置

<bean id="book" class="zwz.pojo.Book">
    <property name="bookName" value="自动装配的BookName"/>
    <property name="pageNum" value="66"/>
</bean>

<!--
- byName 要求所有的bean 的 id 唯一，并且set方法要规范
- byType 要求所有的bean 的 class 唯一，并且set方法要规范
-->
<bean id="bookUser" class="zwz.pojo.BookUser" autowire="byName"/>

测试

@Test
public void testAutowire(){
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    BookUser bookUser = (BookUser) context.getBean("bookUser");
    System.out.println(bookUser);
}

BookUser(book=Book(bookName=自动装配的BookName, pageNum=66))

Process finished with exit code 0

3.8 Java注解开发（推荐）

实体类House

@Data
@AllArgsConstructor
@NoArgsConstructor
public class House {

    @Value("幸福之家")
    private String houseName;

    @Value("99")
    private String houseSize;
}

XML配置

<!--使用注解必须开启注解支持-->
<context:annotation-config/>

<bean id="house" class="zwz.pojo.House"/>

测试

@Test
public void testJava(){
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    House house= (House) context.getBean("house");
    System.out.println(house);
}

House(houseName=幸福之家, houseSize=99)

Process finished with exit code 0

3.9 spring常用注解

@Autowired 直接在变量上使用，也可以在set方法上使用，需要符合名字byName原则 【最常用！！！】
@Nullable 直接在变量上使用，表示这个变量允许为空
@Qualifier(value=“xxx”) 直接在变量上使用，指定bean的id
@Resource 或者 @Resource(value=“xxx”) ，同 @Autowired 和 @Qualifier(value=“xxx”)
@Value(“xxx”)，在实体类的某个变量注入值，也可放在set方法上
@Component，在spring中注册装配bean，通用
@Repository，在spring中注册装配bean，一般放在Dao层上
@Service，在spring中注册装配bean，一般放在Service层上
@Controller，在spring中注册装配bean，一般放在Controller层上
@Scope(“prototype/singleton”)，配置实体类的单例/原型模式
@Configuration，Java配置类的注解

四、 AOP 面向切面编程

4.1 静态代理

抽象角色：接口/抽象类，代表某种需求【租房】
真实角色：被代理的角色【房东】
代理角色：代理真实角色【租房中介】
客户：访问代理对象【租房的人】

假设场景：XX通信公司在高校内售卖校园卡

【抽象角色】就是卖卡这个需求

// 卖校园卡
public interface SellingCard {
    void sellingCard();
}

【真实角色】要卖卡的公司

public class Company implements SellingCard{
    @Override
    public void sellingCard() {
        System.out.println("XX公司要卖校园卡!");
    }
}

【代理角色】高校内的各级代理，卖卡之余，还提供各种服务

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Proxy implements SellingCard{
    private Company company;

    @Override
    public void sellingCard() {
        learnCard();
        company.sellingCard();
        contract();
        collectMoney();
    }

    // 了解校园卡功能
    public void learnCard(){
        System.out.println("校园卡代理带你了解校园卡费用");
    }

    // 收取卖卡推销费用
    public void collectMoney(){
        System.out.println("收取卖卡推销费用");
    }

    // 代理指导你签电子合同
    public void contract(){
        System.out.println("代理指导你签电子合同");
    }
}

【客户】买卡的学生，访问代理角色，buyCard()为直接找公司购卡，buyCardProxy()为找代理购卡

public class Student {

    @Test
    public void buyCardProxy(){
        // XX校园卡公司,要卖校园卡
        Company company = new Company();
        //代理中介,帮公司卖卡，收取一定费用
        Proxy proxy = new Proxy(company);
        // 客户不用面对公司，直接找代理买卡即可
        proxy.sellingCard();
    }
    
    @Test
    public void buyCard(){
        Company company = new Company();
        company.sellingCard();
    }
}

校园卡代理带你了解校园卡费用
XX公司要卖校园卡!
代理指导你签电子合同
收取卖卡推销费用

Process finished with exit code 0

代理模式的优点：

让真实角色的需求【房东卖房】更加简单，不用去关注一些其他手续【客户看房，签合同等】
其他手续交给了代理，实现业务分工
其他手续需求扩展时，方便集中管理

代理模式的缺点：

一个真实角色【房东】，就会产生一个代理角色【租房中介】，使得代码量会翻倍

4.2 动态代理

和静态代理一样，也是卖卡这个场景

【需求】卖卡（同静态代理一致）

// 卖校园卡
public interface SellingCard {
    void sellingCard();
}

【真实角色】要卖卡的公司（同静态代理一致）

public class Company implements SellingCard {
    @Override
    public void sellingCard() {
        System.out.println("XX公司要卖校园卡!");
    }
}

【代理角色】动态代理

@Data
@AllArgsConstructor
@NoArgsConstructor
public class ProxyAction implements InvocationHandler {

    // 被代理的接口
    private SellingCard sellingCard;

    public Object getProxy(){
        return  Proxy.newProxyInstance(this.getClass().getClassLoader(),
                sellingCard.getClass().getInterfaces(),this);
    }

    // 处理代理实例，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        learnCard();
        // 动态代理  反射机制实现
        Object result = method.invoke(sellingCard, args);
        collectMoney();
        contract();
        return result;
    }

    // 了解校园卡功能
    public void learnCard(){
        System.out.println("校园卡代理带你了解校园卡费用");
    }

    // 收取卖卡推销费用
    public void collectMoney(){
        System.out.println("收取卖卡推销费用");
    }

    // 代理指导你签电子合同
    public void contract(){
        System.out.println("代理指导你签电子合同");
    }
}

【客户】买卡的学生

public class Student {
    @Test
    public void testProxyAction(){
        // 真实角色
        Company company = new Company();

        // 代理角色
        ProxyAction pa = new ProxyAction();
        // 通过调用程序处理调用的接口对象 | 就是让代理实现 SellingCard 卖卡的接口
        pa.setSellingCard(company);
        // 获得代理类 | proxy 就是动态生成的
        SellingCard proxy = (SellingCard) pa.getProxy();
        proxy.sellingCard();
    }
}

4.3 Spring API接口实现

Aop是什么？一般情况下，在程序执行时，是从上到下执行的
如果要在执行的某个点，插入一个功能，如何实现？
比如一个系统，我需要加入逻辑删除，我需要增加日志功能，难道我去修改原有代码？
这就需要我们使用Aop来实现横向切入，增加功能！

我们以增加日志功能为例，介绍Aop的实现流程之一 —— 基于Spring API接口实现

编写一个Service

public interface BookService {
    void add();
    void delete();
    void update();
    void select();
}

编写Service的实现类

public class BookServiceImpl implements BookService {
    public void add() {
        System.out.println("增加了一本书");
    }

    public void delete() {
        System.out.println("删除了一本书");
    }

    public void update() {
        System.out.println("修改了一本书");
    }

    public void select() {
        System.out.println("查询了一本书");
    }
}

编写方法前日志

public class BeforeLog implements MethodBeforeAdvice {
    /**
     * method要执行的目标对象的方法
     * args 参数
     * target 目标对象
     */
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName() + " 的 "+method.getName() + " 被执行了!");
    }
}

编写方法后日志

public class AfterLog implements AfterReturningAdvice {
    /**
     * returnValue  返回对象
     * method要执行的目标对象的方法
     * args 参数
     * target 目标对象
     */
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了 " +method.getName() + " 方法, 返回结果为" + returnValue);
    }
}

配置文件配置切面、切入点

<?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"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:p="http://www.springframework.org/schema/p"
       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/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="bookService" class="zwz.demo1.service.BookServiceImpl"/>
    <bean id="beforeLog" class="zwz.demo1.log.BeforeLog"/>
    <bean id="afterLog" class="zwz.demo1.log.AfterLog"/>

    <!--配置AOP-->
    <aop:config>
        <!-- 切入点-->
        <aop:pointcut id="pointcut" expression="execution(* zwz.demo1.service.BookServiceImpl.*(..))"/>
        <!--执行环绕增加 ,将beforeLog切入到pointcut中 -->
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

测试

@Test
public void testAop1(){
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    BookService bookService = (BookService) context.getBean("bookService");
    bookService.add();
}

这样，我们就实现了在执行某个方法的时候，输出日志的功能了

输出结果

zwz.demo1.service.BookServiceImpl 的 add 被执行了!
增加了一本书
执行了 add 方法, 返回结果为null

Process finished with exit code 0

4.4 自定义类实现

接下来是基于自定义类接口实现，和spring的API实现一样，先写业务的实现接口和实现类

public interface BookService2 {
    void add();
    void delete();
    void update();
    void select();
}

public class BookServiceImpl2 implements BookService2 {
    public void add() {
        System.out.println("增加了一本书");
    }

    public void delete() {
        System.out.println("删除了一本书");
    }

    public void update() {
        System.out.println("修改了一本书");
    }

    public void select() {
        System.out.println("查询了一本书");
    }
}

和spring API方法一致，编写两个切入日志类

public class BeforeLog implements MethodBeforeAdvice {
    /**
     * method要执行的目标对象的方法
     * args 参数
     * target 目标对象
     */
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName() + " 的 "+method.getName() + " 被执行了!");
    }
}

public class AfterLog implements AfterReturningAdvice {
    /**
     * returnValue  返回对象
     * method要执行的目标对象的方法
     * args 参数
     * target 目标对象
     */
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了 " +method.getName() + " 方法, 返回结果为" + returnValue);
    }
}

编写自定义切入类

public class DiyPointCut {
    public void before(){
        System.out.println("==============方法执行前==============");
    }
    public void after(){
        System.out.println("==============方法执行后==============");
    }
}

配置文件

<bean id="bookService2" class="zwz.demo2.service.BookServiceImpl2"/>

<!--方式二：采用自定义类 配置AOP-->
<bean id="diy" class="zwz.demo2.diy.DiyPointCut"/>
<aop:config>
    <!-- 自定义切面  ref要引用的类-->
    <aop:aspect ref="diy">
        <!-- 切入点-->
        <aop:pointcut id="point" expression="execution(* zwz.demo2.service.BookServiceImpl2.*(..))"/>
        <!-- 通知-->
        <aop:before method="before" pointcut-ref="point"/>
        <aop:after method="after" pointcut-ref="point"/>
    </aop:aspect>
</aop:config>

测试

    @Test
    public void testAop2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookService2 bookService2 = (BookService2) context.getBean("bookService2");
        bookService2.add();
    }

==============方法执行前==============
增加了一本书
==============方法执行后==============

4.5 Java注解实现

和之前两个方法一样，先写Service服务层的接口和实现类

public interface BookService3 {
    void add();
    void delete();
    void update();
    void select();
}

public class BookServiceImpl3 implements BookService3 {
    public void add() {
        System.out.println("增加了一本书");
    }
    public void delete() {
        System.out.println("删除了一本书");
    }
    public void update() {
        System.out.println("修改了一本书");
    }
    public void select() {
        System.out.println("查询了一本书");
    }
}

切面类

@Aspect  //标注这个类是一个切面
public class PointCut {
    @Before("execution(* zwz.demo3.service.BookServiceImpl3.*(..))")
    public void before(){
        System.out.println("==============方法执行前==============");
    }
    @After("execution(* zwz.demo3.service.BookServiceImpl3.*(..))")
    public void after(){
        System.out.println("==============方法执行后==============");
    }
}

配置文件

<!--方式三：采用注解 配置AOP-->
<bean id="bookService3" class="zwz.demo3.service.BookServiceImpl3"/>
<bean id="pointCut" class="zwz.demo3.cut.PointCut"/>
<!--开启注解支持  默认JDK实现（proxy-target-class="false"）||  也有cglib-->
<aop:aspectj-autoproxy/>

测试类

@Test
public void testAop3(){
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    BookService3 bookService3 = (BookService3) context.getBean("bookService3");
    bookService3.add();
}

输出结果

==============方法执行前==============
增加了一本书
==============方法执行后==============

五、总结

5.1 总结&附录

spring是一个粘合剂，可以整合其他优秀的框架，大大简化了软件开发的复杂度

我认为spring的核心内容：

IOC控制反转
AOP面向切面编程

其他内容比如整合mybatis、声明式事务，在后续再写。

5.2 模板文件

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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
</beans>

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
    PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <package name="zwz.pojo"/>
    </typeAliases>
    <environments default="zwz">
        <environment id="zwz">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper class="zwz.mapper.UserMybatisMapper"></mapper>
    </mappers>
</configuration>

5.3 spring配置标签

bean

bean用来注册实体类，可以注入相应的变量值

<bean id="user" class="zwz.pojo.User">
    <property name="name" value="ZWZ"/>
    <property name="age" value="18"/>
</bean>

alias

设置别名，设置后原名和别名都可以使用

bean 中的 name 属性也可以做别名，而且功能更加强大

<bean id="user" class="zwz.pojo.User">
    <property name="name" value="ZWZ"/>
    <property name="age" value="18"/>
</bean>

<alias name="user" alias="userZwz"/>

可以在测试类中这样调用别名bean

// ApplicationContext Spring上下文对象 | ClassPathXmlApplicationContext 从配置文件中去取
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
// 从容器中取出user对象
User user = (User) context.getBean("userZwz");

import

在团队开发中，每个人都需要拥有自己的配置文件，可以通过import标签将多个配置文件整合成一个

如张三的配置文件 —— bean1.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="user" class="zwz.pojo.User">
        <!-- property相当于给某个变量设置一个值-->
        <property name="name" value="ZWZ"/>
        <property name="age" value="18"/>
    </bean>
    <alias name="user" alias="userZwz"/>
</beans>

团队整体的配置文件 —— 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">
    <import resource="bean1.xml"/>
</beans>

context

自动装配bean

<context:annotation-config/>

扫描指定包的组件

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

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2023-07-31，如有侵权请联系 cloudcommunity@tencent.com 删除

spring

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！