spring之IOC与AOP

IOC

ioc即控制反转（inversion of control），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

ioc的优点就在上面：减低计算机代码之间的耦合度
ioc的缺点也有：耦合性高，可维护性差。

Spring 的配置：

<?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容器来管理  -->
    <bean id="ATService" class="service.impl.ATserviceImpl"></bean>
    <bean id="ATDao" class="dao.impl.ATDaoImpl"></bean>
</beans>

spring的注入：
①构造函数注入：

<bean id="ATService" class="service.impl.ATserviceImpl">
    <constructor-arg name="name" value="ATFWUS"></constructor-arg>
    <constructor-arg name="age" value="18"></constructor-arg>
    <constructor-arg name="birthday" ref="date"></constructor-arg>
</bean>
<bean id="date" class="java.util.Date"></bean>

使用构造函数注入，需要在标签内使用。
属性：

type：指定注入的数据类型
index：指定要注入数据在构造函数参数列表的索引位置。
name：参数在构造函数中的名称。
value：对指定参数赋值。（仅可以是基本数据类型和String型）
ref：赋值。（在该配置文件中已配置的其它bean类型）

②set方法注入：

<bean id="ATService" class="service.impl.ATserviceImpl">
    <property name='mypro'>
	<pros>
		<prop key='A'>a</prop>
		<prop key='B'>b</prop>
	</prop>
</property>
</bean>
<bean id="date" class="java.util.Date"></bean>

需要原类提供set方法。（需要注意）
使用此种注入方式，需要使用标签。

属性：

name：set方法名称后面部分，如setName，这里是name。
value：给属性赋值。（只可以是基本数据类型和String）
ref：赋值，其它bean类型。

以下是对应的注解：
@Component:先需要在xml文件中告知Spring创建容器时需要扫描的包.
@Controller：一般用于表现层的注解。
@Service：一般用于业务层的注解。
@Repository：一般用于持久层的注解。
@Qualifier在自动按照类型注入的基础之上，再按照 Bean 的 id 注入。它在给字段注入时不能独立使用，必须和@Autowire一起使用；但是给方法参数注入时，可以独立使用。属性value：指定 bean的 id。
@Resource：直接按照 Bean的 id注入。只能注入其他 bean类型。属性name：指定bean的id。
@Value：注入基本数据类型和 String类型数据，属性value：指定注入的值。
@configuration:用于指定当前类是一个 spring 配置类，当创建容器时会从该类上加载注解

AOP

aop即面向切片编程：Aspect Oriented Programming。AOP技术的意义在我看来就是为了解除代码的耦合性，可以实现代码的复用。

AOP的核心是代理：

静态代理：

静态代理是在程序运行前就已经存在代理类的字节码文件，代理类和原始类的关系在运行前就已经确定。
说通俗点就是：静态代理需要指定好代理类和原始工厂类，而如果需要改变代理类的代码的话会出现牵一发而动全身的现象。所以动态代理就应运而生.

动态代理：

动态代理的核心是使用反射创建对象。动态代理用到了JDK官方提供的Proxy类。使用jdk生成的动态代理的前提是目标类必须有实现的接口。在这个代理的过程中JDK动态生成了一个类去实现接口。

主要代码如下：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class AppleProxy{
    private Object target;

    public AppleProxy(IAppleCore target) {
        this.target = target;
    }

    public Object getProxyInstance(){
        Object proxy= Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                //增强的方法
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        String methodName=method.getName();
                        Object result=null;
                        if("saleAfter".equals(methodName)){
                            System.out.println("检测到售后方法，开始代理");
                            result=method.invoke(target,args);
                            System.out.println("代理成功");
                        }else{
                            result=method.invoke(target,args);
                        }
                        return result;
                    }
                }
        );
        return proxy;
    }
}