spring AOP+IOC 回顾

问题：

1，什么是spring?

2，什么是IOC，它的原理是什么？

3，什么是AOP，它的原理是什么？

一，什么是spring?

定义：它是一个免费的开源框架，用来解决：业务逻辑层和其他各层的松耦合问题。

优点：免费，轻量，支持事物，支持IOC+AOP

组成：

Spring-Core：提供一个使用IOC创建bean并管理bean的容器

Spring-Context：是一个配置文件，向Spring框架提供上下文信息。提供的服务有：JNDI、EJB、电子邮件、国际化、校验和调度功能。

Spring-Aop：提供了对面向切面编程的丰富支持。例如：方法拦截器和切点

Spring-Dao：对传统的JDBC进行了抽象，并提供明性事务管理方法。

Spring-Web：Web模块建立于Content模块之上，提供了WEB开发的基础集成特性，便于集成WEB框架，如Struts、Webwork、tapest

Spring Web MVC：一个功能全面的MVC框架。

Spring-ORM：为主流的ORM框架提供了模板之类的辅助类，达成了一致的编程风格，如hibernate，mybatis

二，spring IOC

IOC定义：inversion of control 是一种设计思想，指：创建对象控制权的转移，以前创建对象的主动权和创建时机是由自己把控的（new），而现在这种权力转移到IOC容器（使用反射进行创建）

描述：

原来：new UserDao进行使用，使用后销毁。

现在：IOC读取配置，将UserDao对象创建放入IOC容器，当你需要使用UserDao对象时，IOC容器提供对象给你进行使用

目标：1，实现对象创建和使用的解耦，2，对象的创建交给IOC容器后，使得程序员将重心聚焦到业务逻辑的实现上。

降低耦合：例如：现有A类调用B类和C类，B类和C类是接口D的实现，原有的方式A类中需要对B类和C类对象new出来后使用这就造成A,B,C三个类强耦合

如果引入IOC，B类和C类对象都交给IOC创建，A类只需要使用接口D引用来接收B和C类的对象，这样耦合变为了A和D的耦合。后期D接口的实现类变多了，耦合度也不会发生改变。

原理：

1，编写bean.xml配置；

2，程序启动时读取配置；

3，通过反射创建对象并放入IOC容器中；

4，使用时可以直接从容器中获取对象

补充链接：https://www.cnblogs.com/xdp-gacl/p/4249939.html

三，spring AOP

2，代理模式：

分类：静态代理，动态代理

案例说明：用户向房东租房，用户通过中介向房东租房

代码实现：host房东类和rentAgent租房中介类实现了rent租房接口的出租方法，rentAgent将host作为自己的属性，来完成对它的代理操作。

动态代理相比静态代理的优点：静态代理，如果接口中能够有几个方法就需要写对应的几个代理方法，动态代理将所有方法都统一成一个方法，使用method参数进行回调

静态代理实现：

package com.jianjiang;

import lombok.AllArgsConstructor;
import lombok.Data;

public class Test
{
    public static void main(String[] args)
    {
        User user = new User("小明");
        Host host = new Host("房东");
        RentAgent agent = new RentAgent(host);

        //未使用代理
        host.rentHousing(user.getName());
        //使用代理，对原有的方法进行了增强
        agent.rentHousing(user.getName());
    }
}
interface Rent
{
    void rentHousing(String name);
}
@Data
@AllArgsConstructor
class Host implements Rent
{
    private String name;
    @Override
    public void rentHousing(String name)
    {
        System.out.println("将房子出租给"+name);
    }
}
@Data
@AllArgsConstructor
class RentAgent implements Rent
{
    private Host host;
    @Override
    public void rentHousing(String name)
    {
        reviewHousing(name);
        host.rentHousing(name);
        signContract(name);
    }
    private void reviewHousing(String name)
    {
        System.out.println("带"+name+"去看房");
    }
    private void signContract(String name)
    {
        System.out.println("与"+name+"签合同");
    }
}
@Data
@AllArgsConstructor
class User
{
    private String name;
}

动态代理实现

import lombok.AllArgsConstructor;
import lombok.Data;
 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.logging.Handler;
 
public class Test
{
    public static void main(String[] args)
    {
        User user = new User("小明");
        Host host = new Host("房东");
        RentAgentHandler handler = new RentAgentHandler(host);
 
        Rent agent = (Rent) handler.getAgent();
        agent.rentHousing(user.getName());
    }
}
 
interface Rent
{
    void rentHousing(String name);
}
 
@Data
@AllArgsConstructor
class Host implements Rent
{
    private String name;
    @Override
    public void rentHousing(String name)
    {
        System.out.println("将房子出租给"+name);
    }
}
 
@Data
@AllArgsConstructor
class RentAgentHandler implements InvocationHandler
{
    private Object target;
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        reviewHousing(args[0].toString());
        Object invoke = method.invoke(target, args);
        signContract(args[0].toString());
        return invoke;
    }
 
    public Object getAgent()
    {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }
    private void reviewHousing(String name)
    {
        System.out.println("带"+name+"去看房");
    }
    private void signContract(String name)
    {
        System.out.println("与"+name+"签合同");
    }
}
 
@Data
@AllArgsConstructor
class User
{
    private String name;
}