Spring

Spring是一个开源的控制反转(Inversion of Control ,IOC)和面向切面(Aspect Oriented Programmin ,AOP)的容器框架.
IOC和AOP是它的两个重要特性。
依赖注入(Dependency Injection，DI)是控制反转的重要部分，它的主要目的是简化企业开发。
依赖注入就是指：在运行期，由外部容器动态地将依赖对象注入到组件中。

xml文件配置

bean标签

id属性是bean的唯一标识，用来获取此bean类的对象，
class属性是类的全限定名，不能是接口
scope默认是singleton单例模式，也可以设置成prototype多例，每次getBean获取的都是新的对象
lazy-init="default"默认在加载配置文件时创建所有的类对象,也可以设置为true加载配置文件时不创建对象，只有在使用时才创建
init-method=“init”,对象创建完成初始化地方法，只执行一次
destroy-method="desstroy"对象销毁调用的方法，只执行一次

property标签根据类中的各个属性名称初始化值

<bean id="Xxx" class="全限定名">
        <!-- 给bean中不同的属性初始化值 -->
        <property name="inValue" value="1"/>
        <property name="strValue" value="李四"/>
        <property name="arrayValue">
            <array>
                <value>张三</value>
                <value>李四</value>
                <value>王五</value>
            </array>
        </property>
        <property name="listValue">
            <list>
                <value>张三</value>
                <value>李四</value>
                <value>王五</value>
            </list>
        </property>
        <property name="setValue">
            <set>
                <value>张三</value>
                <value>李四</value>
                <value>王五</value>
            </set>
        </property>
        <property name="mapValue">
            <map>
                <entry key="1" value="张三"/>
                <entry key="2" value="李四"/>
                <entry key="3" value="王五"/>
            </map>
        </property>
        <property name="propValue">
            <props>
                <prop key="1">张三</prop>
                <prop key="2">李四</prop>
                <prop key="3">王五</prop>
            </props>
        </property>
    </bean>

使用
加载xml配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("/xml文件名.xml");
通过 .getBean("xml文件中设置的id名“)调用，有可通过 。getBean(类名.class)调用
User user = (User)context.getBean(“user”);
User user1 = context.getBean(User.class);

开启注解模式，使用注解需要开启注解
< context:annotation-config/>
配置组件包扫描,指定基本的包名称，自动扫描该报以及子包下面的所有类，
查找类上由注解@Component、@Controller、@Service、@Repository自动创建对象
<context:component-scan base-package=“com.entor.entity”/>

Spring注解

@Controller、@Service、@Repository、 @Component 作用在类上
作用：相当于配置文件中一个bean标签，默认的id属性名称是该类名的首字母小写格式，也可以指定名称
以上四个注解都是用在类上面，作用类似，主要区别是用来标识不同类型的对象
@Controller 注解用来标识处理客户端请求类
@Service 注解用来标识业务处理类
@Repository 注解用来标识数据访问层处理了
@Component 注解用来标识除了上面三个标识以外其他组件

@Resource 注解在属性上面，
作用：根据属性名称去配置文件中获取对应id名称的bean对象，找到之后赋值给该属性，如果找不到则根据属性类型去配置文件中查找,如果找到多个则报错，使用注解后可以省略get、set方法
@Autowired 注解用在属性上面，
作用：根据属性类型去配置文件查找对象，如果找到多个，在根据属性名称去配置文件中查找，如果找不到则报错
可以配合@Qualifier注解使用，指定名称去查找，如果找不到则报错，不会再根据属性名称去查找

AOP

静态代理（staticproxy）

代理类实现接口，在实现类方法中添加方法
缺点：接口发送改变，类也将发生改变重写

public class Proxy implements UserService{
    private UserService userService;
    public Proxy(UserService userService){
        this.userService=userService;
    }
    @Override
    public void delete() {
        check();
        userService.delete();
    }
    public void check(){
        System.out.println("权限检查");
    }
}

动态代理（jdkproxy）

可根据调用的对象、方法，动态实现代理
传入目标对象创建目标代理对象,目标对象必须 实现接口的类,目标对象没有实现接口类，无法代理
代理类实现InvocationHandler接口

/**
 * jdk动态代理，代理的目标对象必须要实现接口
 */
public class JDKProxy implements InvocationHandler {

    private Object targetOject;

    /**
     * 根据传入的目标对象创建代理对象
     * @param targetOject 目标对象
     * @return
     */
    public Object createProxy(Object targetOject){
        this.targetOject = targetOject;
        return Proxy.newProxyInstance(targetOject.getClass().getClassLoader(),
                targetOject.getClass().getInterfaces(),
                this);
    }

    /**
     *
     * @param o 代表动态代理对象
     * @param method 代表正在执行的方法
     * @param objects 代表调用目标方法时传入的实参
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
        if (method.getName().equals("delete")){
            check();
        }

        Object result = method.invoke(this.targetOject, objects);
        return result;
    }
    public void check(){
        System.out.println("权限校验");
    }

}

cglib代理（cglibproxy）

在动态代理的基础上实现了无接口代理
一次只可以代理一个对象

public class CglibProxy implements MethodInterceptor {

    private Object tar;

    public Object createtar(Object tar){
        this.tar = tar;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.tar.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        if (method.getName().equals("giveMoney")){
            click1();
        }
        if (method.getName().equals("give")){
            click2();
        }
        Object invoke = method.invoke(this.tar, objects);
        return invoke;
    }
    private void click1(){
        System.out.println("交费成功！");
    }
    private void click2(){
        System.out.println("扫地完成！");
    }
}

aop

在cglib代理的基础是实现多代理

xml

通过xml配置文件实现代理

annotation

通过注解实习代理