9、使用Java的方式配置Spring

我们现在要完全不使用Spring的xml配置了，全权交给Java来做！

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

实体类

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

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

    public String getName() {
        return name;
    }
    @Value("尹锐")
    public void setName(String name) {
        this.name = name;
    }
}

配置文件

package com.rui.config;

import com.rui.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
@Import(RuiConfig2.class)
public class RuiConfig {

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

测试类

public class MyTest {
    public static void main(String[] args) {

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

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

10、代理模式

为什么要学习代理模式？因为这就是SpringAOP的底层【SpringAOP和SpringMVC】

代理模式的分类：

• 静态代理
• 动态代理

10.1、静态代理

角色分析：

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

代码步骤：

1. 接口

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

2. 真实角色

   //房东
   public class Host implements Rent {
       @Override
       public void rent(){
           System.out.println("房东要出租房子！??");
       }
   }

3. 代理角色

   package com.rui.demo01;
   
   public class Proxy implements Rent {
       private Host host;
   
       public Proxy() {
       }
   
       public Proxy(Host host) {
           this.host = host;
       }
   
       @Override
       public void rent() {
           seeHouse();
           host.rent();
           hetong();
           fare();
       }
       //看房
       public void seeHouse(){
           System.out.println("中介带你看房");
       }
   
       //签署合同
       public void hetong(){
           System.out.println("签租赁合同");
       }
   
       //收取中介费
       public void fare(){
           System.out.println("收取中介费");
       }
   }

4. 客户端访问代理角色

   package com.rui.demo01;
   
   public class Client {
       public static void main(String[] args) {
           //房东要租房子
           Host host = new Host();
           //代理，中介帮房东租房子，但是呢代理角色一般会有一些附属操作！
           Proxy proxy = new Proxy(host);
           //你不用面对房东，直接找中介租房即可！
           proxy.rent();
       }
   }

代理模式的好处：

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

缺点：

• 一个真实角色就会产生一个代理角色；代码量会翻倍～开发效率会变低

10.2、加深理解

代码：对应08-demo02

聊聊AOP

10.3、动态代理

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

需要了解两个类：Proxy（代理）、InvocationHandler（调用处理程序）

InvocationHandler

动态代理的好处：

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

原文地址：https://www.cnblogs.com/MrKeen/p/12028981.html