Spring

最新推荐文章于 2025-01-02 13:42:06 发布

小钟技术杂货铺

最新推荐文章于 2025-01-02 13:42:06 发布

阅读量100

点赞数

分类专栏： Spring

本文链接：https://blog.youkuaiyun.com/jiaweizhong/article/details/118048257

版权

Spring 专栏收录该内容

2 篇文章

订阅专栏

1、Spring

1.1简介

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

spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架。

SSM:springmvc +spring+mybatis

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

1.2优点

spring 是一个开源的免费的框架（容器）

spring是一个轻量级的、非入侵式的矿机
控制反转、面向切面编程
支持事务的处理，对框架整合的支持

总结一句话：Spring 是一个轻量级控制反转（IOC）和面向切面（AOP）的容器框架

1.3 组成

spring七大核心组成

## 1.4 拓展

在spring的官网中有这个介绍，现代化的java开发，说白了就是基于Spring的开发

在这里插入图片描述

springboot
- 一个快速开发的脚手架
- 基于SpringBoot可以快速的开发单个微服务
springcloud
- springcloud是基于springboot实现的

因为现在大多数公司都在使用springboot进行快速开发，学习springboot的前提，需要完全掌握spring及springmvc 承上启下

弊端：发展了太久之后，违背了原来的理念，配置十分繁琐，人称：配置地狱。

2、IOC理论推导

1、UserDao接口

2、UserDaoImpl实现类

3、UserService业务接口

4、UserServiceImpl 业务实现类

dao层

public interface UserDao {
     void getUser();
}

public class UserDaoImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("默认获取用户信息");
    }
}

public class UserDaoMysqlImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("Mysql获取用户信息");
    }
}

service层

public interface UserService {
    void getUser();
}

public class UserServiceImpl implements UserService {
    private UserDao userDao = new UserDaoImpl();
    @Override
    public void getUser() {
        userDao.getUser();
    }
}

测试类

public class UserServiceImplTest {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        userService.getUser();
    }
}

优化修改后

dao层

public interface UserDao {
     void getUser();
}

public class UserDaoImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("默认获取用户信息");
    }
}

public class UserDaoMysqlImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("Mysql获取用户信息");
    }
}

service层

public interface UserService {
    void setUserDao(UserDao userDao);
    void getUser();
}

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

测试类

public class UserServiceImplTest {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        userService.setUserDao(new UserDaoMysqlImpl());
        userService.getUser();
    }
}

在我们之前的代码中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求区修改原代码。

之前，程序是主动创建对象，控制权在程序员手上。
使用了set注入后，程序不再具有主动性，而是变成了被动接受的对象。

这种思想，从本质上解决了问题，我们程序员不用再去管理对象的创建了。系统的耦合性大大降低，可以更加专注的再业务的实现上。这是IOC原型。
在这里插入图片描述
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GrknQaBy-1624189351023)(/Users/zhongjiawei/Desktop/屏幕快照 2021-06-19 下午5.03.48.png)]

IOC的本质

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

没有IOC的程序中，我们使用面向对象编程，对象的创建和对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方。

个人认为所谓的控制反转就是：获得依赖对象的方式反转了。

Ioc是Spring框架的核心内容，使用多种方式完美的实现了Ioc，可以使用xml，也可以使用注解，新版本的spring也可以零配置实现Ioc

spring容器在初始化时读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

在这里插入图片描述
采用xml方式配置bean的时候，bean的定义信息时和实现分离的，采用注解的方式可以把两者合为一体，bean的定义信息直接以注解的形式定义在实现类中，从而达到零配置的目的。

控制反转是一种通过描述（xml 或注解）并通过第三方区生产或获取特定对象的方式。

在spring中实现控制反转的是ioc容器，其实现方式是依赖注入DI。

3、 HelloSpring

Hello 对象是谁创建的？

hello对象是由spring创建的
Hello对象的属性是怎么设置的？

hello对象的属性是由spring容器设置的。

public class Hello {
    private String name;

    public String getName() {
        return name;
    }

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

public class HelloSpringTest {
    public static void main(String[] args) {
        //获取Spring的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //我们对象现在都在Spring管理了，我们要使用，直接去取出来就可以了。
        Hello result = (Hello) context.getBean("hello");
        System.out.println(result.getName());

    }
}

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

    <!--
        使用spring来创建对象，在spring这些都称为Bean
        相当于：
        Hello bean = new Hello()
        id = 就是实例对象名bean；
        property 相当于给属性设值。
    -->
    <bean id="hello" class="com.zjw.pojo.Hello">
        <property name="name" value="Spring"></property>
        <!-- collaborators and configuration for this bean go here -->
    </bean>
</beans>

这个过程就叫控制反转。

控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用spring后，对象是由spring来创建的

4、IOC创建对象的方式

1、使用无参构造创建对象，默认。

2、假设我们要使用有参构造创建对象

public class Hello {
    private String name;


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

    public String getName() {
        return name;
    }

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

下标赋值

 <bean id="hello" class="com.zjw.pojo.Hello">
       <constructor-arg index="0" value="springtest"/>
        <!-- collaborators and configuration for this bean go here -->
    </bean>

2、或者类型赋值，但不建议使用，假如有两个参数，都是string

 <bean id="hello" class="com.zjw.pojo.Hello">
       <constructor-arg type="java.lang.String" value="springtest"/>
        <!-- collaborators and configuration for this bean go here -->
    </bean>

3、通过参数名

 <bean id="hello" class="com.zjw.pojo.Hello">
       <constructor-arg name="name" value="springtest"/>
        <!-- collaborators and configuration for this bean go here -->
    </bean>

5、spring配置

import 适合团队开发，它可以将多个配置文件，导入合并为一个。

 <import resource="bean2.xml"/>

多个xml重复创建对象会被合并。容器中一个实例对象只存在一份。

6、依赖注入

6.1 构造器注入

6.2 set方式注入

依赖注入：set 注入

依赖：bean对象的创建依赖容器

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

【环境搭建】

package com.zjw.pojo;

import java.util.*;

/**
 * @author jw.z
 * @date 2021/6/19 10:01 下午
 */
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 String getName() {
        return name;
    }

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

    public Address getAddress() {
        return address;
    }

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

    public String[] getBooks() {
        return books;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public List<String> getHobbies() {
        return hobbies;
    }

    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    public Map<String, String> getCard() {
        return card;
    }

    public void setCard(Map<String, String> card) {
        this.card = card;
    }

    public Set<String> getGames() {
        return games;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public String getWife() {
        return wife;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    public Properties getInfo() {
        return info;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address.toString() +
                ", books=" + Arrays.toString(books) +
                ", hobbies=" + hobbies +
                ", card=" + card +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }
}

public class Address {    private String address;    public String getAddress() {        return address;    }    public void setAddress(String address) {        this.address = address;    }    @Override    public String toString() {        return "Address{" +                "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">

    <!--
        使用spring来创建对象，在spring这些都称为Bean
        相当于：
        Hello bean = new Hello()
        id = 就是实例对象名bean；
        property 相当于给属性设值。
    -->
    <bean id="address" class="com.zjw.pojo.Address">

    </bean>
    <bean id="student" class="com.zjw.pojo.Student">
       <property name="name" value="springtest"/>
        <!-- collaborators and configuration for this bean go here -->
        <property name="address" ref="address"/>
        <property name="card">
            <map>
                <entry key="身份证" value="23444324239"/>
                <entry key="银行卡" value="090809809808"/>
            </map>

        </property>
        <property name="books">
            <array>
                <value>红楼梦</value>
                <value>三国演义</value>
            </array>
        </property>
        <property name="games">
            <set>
                <value>lol</value>
                <value>bob</value>
            </set>
        </property>
        <property name="wife">
           <null></null>
        </property>
        <property name="info">
            <props>
                <prop key="学号">20190517</prop>
                <prop key="性别">男</prop>
            </props>
        </property>
    </bean>

</beans>

6.3 拓展方式注入

7 Bean的自动装配

7.1 搭建测试环境

package com.zjw.pojo;

/**
 * @author jw.z
 * @date 2021/6/19 11:52 下午
 */
public class Person {
    private Dog dog;
    private Cat cat;
    private String name;

    public Dog getDog() {
        return dog;
    }

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

    public Cat getCat() {
        return cat;
    }

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

    public String getName() {
        return name;
    }

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

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

public class Cat {
    public void shout(){
        System.out.println("miao~~");
    }
}

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

public class PersonTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Person person = context.getBean("person",Person.class);
        person.getCat().shout();
        person.getDog().shout();
    }
}

7.2 byName自动装配

<bean id="dog" class="com.zjw.pojo.Dog"/>
<bean id="cat" class="com.zjw.pojo.Cat"/>
<bean id="person" class="com.zjw.pojo.Person" autowire="byName"/> ##通过id查找

7.3 byType自动装配

<bean id="dog" class="com.zjw.pojo.Dog"/>
<bean id="cat" class="com.zjw.pojo.Cat"/>
<bean id="person" class="com.zjw.pojo.Person" autowire="byType"/>##通过class查找

7.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:comtext="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">

    <!-- 开启 注解支持-->
    <comtext:annotation-config/>
    <bean id="dog" class="com.zjw.pojo.Dog"/>
    <bean id="cat" class="com.zjw.pojo.Cat"/>
    <bean id="person" class="com.zjw.pojo.Person" />
</beans>

package com.zjw.pojo;

import org.springframework.beans.factory.annotation.Autowired;

/**
 * @author jw.z
 * @date 2021/6/19 11:52 下午
 */
public class Person {
    @Autowired
    private Dog dog;
    @Autowired
    private Cat cat;
    private String name;
		//使用Autowired注解 ，可以省略掉set方法。
    public Dog getDog() {
        return dog;
    }
    
    public Cat getCat() {
        return cat;
    }

    public String getName() {
        return name;
    }

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

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

使用注解须知：

1、导入约束：context 约束

<?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:comtext="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">

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

2、配置注解的支持 : comtext:annotation-config/

**@Autowired ** 最常用

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

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

假如存在多个实例，可以配合@Qualifier使用

 <comtext:annotation-config/>
    <bean id="dog" class="com.zjw.pojo.Dog"/>
    <bean id="cat" class="com.zjw.pojo.Cat"/>
    <bean id="cat222" class="com.zjw.pojo.Cat"/>
    <bean id="person" class="com.zjw.pojo.Person" />

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

如果@Autowired 自动装配的环境比较复杂，自动装配无法通过一个注解完成的时候，可以配合@Qualifier使用，指定一个唯一的bean注入。

拓展了解：@Resource

@Resource 不是spring的注解，是java的注解，也可以实现自动装配，它整合了spring的byName 和byType

public class Person {
    @Resource
    private Dog dog;
    @Resource
    private Cat cat;
    private String name;
}

小结：@Resource 和 @Autowired 的区别：

都是来自动装配的，都可以放在属性上
@Autowired 通过byType的方式实现，而且必须要求这个对象存在。
@Resource 默认通过byname，如果找不到name ，就通过byType，如果两个都找不到，就报错了。

8 使用注解开发

//等价于 <bean id="user" class="com.zjw.pojo.User"/>
//组件
@Component
public class User {
    public String name;

   // 相当于<property name="name" value="ceshi"/>
    @Value("zjw")
    public void setName(String name) {
        this.name = name;
    }
}

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

dao 【@Repository】

service 【@Service】

controller 【@Controller】

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

小结：xml与注解

xml更加万能，使用于任何场合，维护简单方便

注解不是自己的类使用不了，维护相对复杂

最佳实践：xml用来管理bean；注解只负责属性注入。

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

9 使用java的方式配置spring

完全不使用spring的xml配置，全权交给java来做。

javaconfig 是spring的一个子项目。在spring4之后，它成为了一个核心功能。

配置文件

//这个也会被spring托管，注册到容器中，因为它本身就是一个@Component
    //@Congifuration 代表这是一个配置类，就和我们之前看的beans.xml
@Configuration
@ComponentScan("com.zjw.pojo")
//@Import() 将多个类引入，合成一个类。
public class UserConfig {

    //注册一个bean，就相当于我们之前写的一个bean标签
    //这个方法的名字，就相当于bean标签中的id
    //方法的返回值，就相当于bean标签中的class
    @Bean
    public User user(){
        return new User();//就是要返回要注入到bean的对象
    }
}

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

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

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

public class UserTest {
  @Test
  public void test(){
    //如果完全使用了配置类来实现，我们就只能通过AnnotationConfigApplicationContext上下文来获取容器，通过配置类的class对象加载。
    ApplicationContext context = new AnnotationConfigApplicationContext(UserConfig.class);
    User user =  context.getBean("user",User.class);
    System.out.println(user.getName());
  }
}

10 静态代理模式

为什么要学习代理模式？

因为这就是springAOP的底层

代理模式的分类

静态代理
动态代理

10.1 静态代理

角色分析

抽象角色：一般会使用接口或抽象类来解决

真实角色：被代理的角色

代理角色：代理真实角色后，我们一般会做一些附属操作

客户：访问代理对象的人

代理模式的好处：

可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
公共也就交给代理的角色，实现了业务的分工
公共业务发生扩展的时候方便集中管理。

缺点：

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

被代理的角色：房东

//房东
public class Host {

    public void rest(){
        System.out.println("房东有房出租");
    }
}

抽象角色，接口

public interface Rent {
    public void rent();
}

代理

public class Proxy implements Rent{
    private Host host;
    public Proxy(Host host) {
        this.host = host;
    }

    public void rent() {
        host.rest();
        seeHose();
        hetong();
        fare();
    }

    public void seeHose(){
        System.out.println("中介带看房");
    }
    public void hetong(){
        System.out.println("中介带签合同");
    }
    public void fare(){
        System.out.println("中介收中介费");
    }
}

客户

public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        Proxy proxy = new Proxy(host);
        proxy.rent();

    }
}

10.2 加深静态代理

没有加代理前

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

真实类

public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("增加了一个用户");
    }

    public void delete() {
        System.out.println("删除了一个用户");
    }

    public void update() {
        System.out.println("修改了一个用户");
    }

    public void query() {
        System.out.println("查询了一个用户");
    }
}

客户

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        userService.add();
    }
}

加上代理,原有UserServiceImpl不用动。

public class UserServiceProxy implements UserService{
    private UserServiceImpl userServiceImpl;

    public void setUserServiceImpl(UserServiceImpl userServiceImpl) {
        this.userServiceImpl = userServiceImpl;
    }

    public void add() {
        log("add");
        userServiceImpl.add();
    }

    public void delete() {
        log("delete");
        userServiceImpl.delete();
    }

    public void update() {
        log("update");
        userServiceImpl.update();
    }

    public void query() {
        log("query");
        userServiceImpl.query();
    }

    public void log(String msg){
        System.out.println("使用了"+msg+"方法");
    }
}

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        UserServiceProxy userServiceProxy = new UserServiceProxy();
        userServiceProxy.setUserServiceImpl(userService);
        userServiceProxy.add();
    }
}

AOP

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nUqbFQgh-1624189409801)(/Users/zhongjiawei/Desktop/屏幕快照 2021-06-20 上午9.25.32.png)]

10.3 动态代理

动态代理和静态代理角色一样
动态代理的代理是动态生成的，不是我们直接写好的
动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口–jdk动态代理
- 基于cglib
- java字节码实现：javasist

代理类

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

    //InvocationHandler 是由代理实例的调用处理程序实现的接口。
    //每个代理实例都有一个关联的处理程序，当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法。
    
    //被代理的接口
    private Object target;
    public void setTarget(Object target) {
        this.target = target;
    }

    //Proxy 提供了创建动态代理类和实例的静态方法，它是由这些方法创建的所有动态代理类的超类。
    public Object getPoxy(){
      return   Proxy.newProxyInstance(this.getClass().getClassLoader(),
              target.getClass().getInterfaces(),this);

    }

    //处理代理实例，并返回结果
    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 msg){
        System.out.println("执行了"+msg+"方法");
    }
}

客户类

public class Client {
    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService = new UserServiceImpl();
       //代理角色：现在没有
        ProxyInvocationHandle pih = new ProxyInvocationHandle();
        //通过调用程序处理角色来处理我们要调用的接口对象。
        pih.setTarget(userService);
        //动态生产代理类
        UserService proxy = (UserService) pih.getPoxy();
        proxy.add();

    }
}

动态代理的好处：

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

11 AOP

11.1 什么是AOP

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

11.2 AOP在spring中的作用

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

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

11.3使用spring 实现aop

注意：使用aop织入，需要导入一个依赖包

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

方式一：使用Spring的API接口：主要springapi接口实现

方式二：自定义来实现AOP :主要是切面定义，一个类（切面）中包含多个方法（通知）

方式三：使用注解方式实现AOP

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

    <bean id="userService" class="com.zjw.service.UserServiceImpl"/>

   <!--方式一：使用原生spring api接口-->
    <bean id="before" class="com.zjw.log.BeforeLog"/>
    <bean id="after" class="com.zjw.log.AfterLog"/>
    <!--配置aop-->

    <aop:config>
        <!--切入点-->
        <aop:pointcut id="pointcut" expression="execution(* com.zjw.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增强-->
        <aop:advisor advice-ref="before" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="after" pointcut-ref="pointcut"/>
    </aop:config>


    <!--方式二-->
   <bean id="diyPoint" class="com.zjw.diy.DiyPointCut"/>
     <aop:config>
         <!--自定义切面，ref要引用的类-->
         <aop:pointcut id="pointcut" expression="execution(* com.zjw.service.UserServiceImpl.*(..))"/>
         <aop:aspect ref="diyPoint">
             <aop:before method="before" pointcut="pointcut"/>
             <aop:after method="after" pointcut="pointcut"/>
        </aop:aspect>
     </aop:config>

    <!--通过注解的方式实现AOP-->
     <bean id="annotationPointCut" class="com.zjw.diy.AnnotationPointCut"/>
     <aop:aspectj-autoproxy/>
</beans>

方式一

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

public class AfterLog implements AfterReturningAdvice {

    // o 是返回值
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("执行了"+method.getName()+"返回结果为："+o);
    }
}

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

    public void add() {
        System.out.println("增加了一个用户");
    }

    public void delete() {
        System.out.println("删除了一个用户");
    }

    public void update() {
        System.out.println("修改了一个用户");
    }

    public void query() {
        System.out.println("查询了一个用户");
    }
}

方式二

public class DiyPointCut {
    public  void  before(){
        System.out.println("=======执行开始=======");
    }
    public void after(){
        System.out.println("========执行结束======");
    }
}

方式三

@Aspect
public class AnnotationPointCut {
    @Before("execution(* com.zjw.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("=====start====");
    }

}