四十、Spring 学习二 - 《Java 入门即巅峰》

1、使用注解开发
2、使用Java的方式配置Spring
3、代理模式

1、使用注解开发

在Spring4之后，要使用注解开发，必须要保证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: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>

bean

属性如何注入

// 等价于 <bean id="user" class="com.shuai.pojo.User"/>
// @Component  组件
@Component
public class User {
public String name;
//  相当于 <property name="name" value="少帅"/>
@Value("少帅")
public void setName(String name) {
    this.name = name;
}
}

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

自动装配置

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

作用域

@Component
@Scope("prototype")
public class User {
@Value("少帅")
public String name;
}

小结
xml与注解：
- xml更加万能，适用于任何场合！维护简单方便
- 注解不是自己类使用不了，维护相对复杂！

xml与注解最佳实践：

xml用来管理bean；
注解只负责完成属性的注入；

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

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

2、使用Java的方式配置Spring

实体类

// 这里这个注解的意思，就是说明这个类型被Spring接管了，注册到了容器中
@Component
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 + '\'' +
             '}';
 }
}

配置文件

// 这个也被Spring容器托管，注册到容器中，因为本身就是一个@Component
// @Configuration代表这是一个配置类，就和我们之前看的beans.xml
@Configuration
@ComponentScan("com.shuai.pojo")
public class ShuaiConfig {
 // 注册一个bean,就相当于我们之前写的一个bean标签
 // 这个方法的名字，就相当于bean标签下的id属性
 // 这个方法的返回值，就相当于bean标签中的class属性
 @Bean
 public User getUser(){
     return new User();   // 就是返回要注入到Bean的对象！
 }
}

测试

public class MyTest {
 public static void main(String[] args) {
     ApplicationContext context = new AnnotationConfigApplicationContext(ShuaiConfig.class);
     User getUser = (User) context.getBean("getUser");
     System.out.println(getUser.getName());
 }
}

3、代理模式

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

代理模式的分类：

静态代理
动态代理

3.1、静态代理

角色分析：

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

代理步骤：

接口

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

真实角色

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

代理角色

public class Proxy implements Rent{
private Host host;
public Proxy() {
}
public Proxy(Host host) {
    this.host = host;
}
public void rent() {
    seeHouse();
    host.rent();
    Contract();
    Charge();
}
// 看房
public void seeHouse(){
    System.out.println("中介带你看房");
}
// 签合同
public void Contract(){
    System.out.println("签订合同！！！");
}
// 收费
public void Charge(){
    System.out.println("中介收费");
}
}

客户端访问代理角色

public class Client {
public static void main(String[] args) {
    // 房东要租房子
    Host host = new Host();
    // 代理，中介帮房东出租房子，收取小费
    Proxy proxy = new Proxy(host);
    // 你不用面对房东，直接找中介租房即可！
    proxy.rent();
}
}

代理模式的好处：

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

缺点：

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

3.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 UserServiceProxy implements UserService{
private UserServiceImpl userService;
public void setUserService(UserServiceImpl userService) {
    this.userService = userService;
}
public void add() {
    log("add");
    userService.add();
}
public void delete() {
    log("delete");
    userService.delete();
}
public void update() {
    log("update");
    userService.update();
}
public void query() {
    log("query");
    userService.query();
}
public void log(String msg){
    System.out.println("[debug] 使用一个"+msg+"方法");
}
}

客户端访问代理角色

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

3.3 动态代理

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写好的！
动态代理分为两大类：基于接口的动态代理，基于类的动态代理
基于接口 — JDK动态代理【我们在这里使用】
基于类：cglib
java字节码实现：javassist

需要了解两个类：Proxy：代理；InvocationHandler：调用处理程序。

代码步骤：

接口

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

真实角色

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

ProxyInvocationHandler类

// 我们用这个类，自动生成代理类！
public class ProxyInvocationHandler implements InvocationHandler{
// 被代理的接口
private Rent rent;
public void setRent(Rent rent) {
    this.rent = rent;
}
// 生成得到代理类
public Object getProxy(){
    return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(), this);
}
// 处理代理实例，并返回结果
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    // 动态代理的本质，就是使用反射机制实现！
    Object result = method.invoke(rent, args);
    seeHouse();
    fee();
    return result;
}
public void seeHouse(){
    System.out.println("中介带看房子");
}
public void fee(){
    System.out.println("中介收取小费");
}
}

测试

public class Client {
public static void main(String[] args) {
    // 真实角色
    Host host = new Host();
    // 代理角色：现在没有
    ProxyInvocationHandler pih = new ProxyInvocationHandler();
    // 通过调用程序处理角色来处理我们要调用的接口对象
    pih.setRent(host);
    Rent proxy = (Rent) pih.getProxy();
    proxy.rent();
}
}

在此，我们可以提炼出ProxyInvocationHandler作为工具类

// 我们会用这个类，自动生成代理类！
public class ProxyInvocationHandler implements InvocationHandler {
    // 被代理的接口！
    private Object target;
    public void setTarget(Object target) {
        this.target = target;
    }
    // 得到代理类
    public Object getProxy(){
        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();
        // 代理角色，不存在
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(userService);  // 设置代理的对象
        // 动态生成代理类
        UserService proxy = (UserService) pih.getProxy();
        proxy.delete();
    }
}

动态代理的好处：

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