Spring Aop和Spring Ioc（二）

Spring IOC：

DI注入集合类型：

实体类：

package cn.spring.entity;

import java.util.*;

public class Dientity {
    private String[] array;   　　　　　　//数组

    private List<String> list; 　　　　　//List集合

    private Set<String> set;　　　　 　　//Set集合

    private Map<String,Object> map; 　　//Map集合

    private Properties properties;　　　//Porperties配置

    public String[] getArray() {
        return array;
    }

    public void setArray(String[] array) {
        this.array = array;
    }

    public List<String> getList() {
        return list;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public Set<String> getSet() {
        return set;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public Map<String, Object> getMap() {
        return map;
    }

    public void setMap(Map<String, Object> map) {
        this.map = map;
    }

    public Properties getProperties() {
        return properties;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    @Override
    public String toString() {
        return "Dientity{" +
                "array=" + Arrays.toString(array) +
                ",\n list=" + list +
                ",\nset=" + set +
                ",\n map=" + map +
                ",\n properties=" + properties +
                '}';
    }
}

applicationcontextbean.xml中：

<bean id="dientity" class="cn.spring.entity.Dientity">
　　　　　　　数组注入
        <property name="array" >
            <array>
                <value>李一</value>
                <value>王二</value>
                <value>刘三</value>
            </array>
        </property>
　　　　　　　List集合注入
        <property name="list">
            <list>
                <value>李一</value>
                <value>王二</value>
                <value>刘三</value>
            </list>
        </property>
　　　　　　　　Map集合注入
        <property name="map">
            <map>
                <entry key="name1" value="李一"></entry>
                <entry key="name2" value="王二"></entry>
                <entry key="name3" value="刘三"></entry>
            </map>
        </property>
　　　　　　　　Set集合注入
        <property name="set">
            <set>
                <value>李一</value>
                <value>王二</value>
                <value>刘三</value>
            </set>
        </property>
　　

properties注入
<property name="properties">
    <props>
        <prop key="jdbc.driver">com.mysql.jdbc.Driver</prop>
        <prop key="jdbc.username">root</prop>
    </props>
</property>

　　

</bean>

结果：

域属性自动注入：byName，byType

    <!--byName:实体类中的域属性的名字和id一致-->
     <bean id="studentBean" class="cn.spring.entity.StudentBean" autowire="byName">
        <property name="stu_id" value="18"></property>
        <property name="stu_name" value="VVV"></property>
     <!-- <property name="teacherBean" ref="teacherBean"></property>-->
    </bean>
    <!--byType:类型是唯一的，在applicationtextbean.xml中bean只能有一个。-->
    <bean id="studentBean" class="cn.spring.entity.StudentBean" autowire="byType">
        <property name="stu_id" value="18"></property>
        <property name="stu_name" value="VVV"></property>
       <!-- <property name="teacherBean" ref="teacherBean"></property>-->
    </bean>
    <bean id="teacherBean" class="cn.spring.entity.TeacherBean">
        <property name="T_id" value="9"></property>
        <property name="T_name" value="WWW"></property>
    </bean>

SpringBean的生命周期和作用域：

　　生命周期：

spring bean的作用域：

代理模式：

静态代理：

代理模式可以在不修改被代理对象的基础上，通过扩展代理类，进行一些功能的附加与增强。值得注意的是，代理类和被代理类应该共同实现一个接口，或者是共同继承某个类。

静态代理的内容，为什么叫做静态呢？因为它的类型是事先预定好的。

动态代理：

动态代理有两种：jdk动态代理和Cglib动态代理

jdk动态代理：

JDK动态代理中包含一个类和一个接口：

InvocationHandler接口：
public interface InvocationHandler {
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable;
}
参数说明：
Object proxy：指被代理的对象。
Method method：要调用的方法
Object[] args：方法调用时所需要的参数

　　

可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject。

Proxy类： 
Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,
InvocationHandler h)
                               throws IllegalArgumentException
参数说明：
ClassLoader loader：类加载器
Class<?>[] interfaces：得到全部的接口
InvocationHandler h：得到InvocationHandler接口的子类实例 

Ps:类加载器 
在Proxy类中的newProxyInstance（）方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是类加载器，在Java中主要有一下三种类加载器; 
Booststrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的； 
Extendsion ClassLoader：用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类; 
AppClassLoader：(默认)加载classpath指定的类，是最常使用的是一种加载器。

实例：

Suject接口
package cn.spring.jdkporxy;

/**
 * 抽象主题：真实业务接口
 */

public interface Subject {
   void  doSome();
}

Subject接口实现
package cn.spring.jdkporxy;

/**
 * 真实主题：将业务代码封装到此主题当中
 */
public class RealSubject implements Subject {
    @Override
    public void doSome() {
        System.out.println("========================真实业务====================");
    }
}

package cn.spring.jdkporxy;

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

public class JDKProxyTest {
    public static void main(String[] args) {
        //JDK动态代理，利用了Proxy类生成代理对象      运行期间    必须原对象必须拥有interface   在内存当中生成代理对象
        //cglib动态代理：在编译期间，利用Enhancer类生成代理对象（要求原对象可以不具备接口）

        //JDK动态代理：要求必须有抽象主题
        //代表的是代理对象  指定对象的原始类型

        /**
         * ClassLoader loader,   类加载器：应该是代理对象的类加载器
         * Class<?>[] interfaces,   接口：原始对象实现的接口类型
         * InvocationHandler h
         */
        //创建一个原始对象
        final Subject subject=new RealSubject();
        Subject subjectProxy = (Subject) Proxy.newProxyInstance(subject.getClass().getClassLoader(), subject.getClass().getInterfaces(), new InvocationHandler() {
            /**
             *
             * @param proxy   代理对象
             * @param method    目标代理方法
             * @param args      目标代理方法的参数
             * @return
             * @throws Throwable
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("前置增强");
                //如何去调用原始对象的业务方法
                Object invoke = method.invoke(subject, args);
                System.out.println("后置增强");
                return invoke;
            }
        });
        subjectProxy.doSome();
        System.out.println(subject);
        System.out.println(subjectProxy);

    }
}

　　

动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。

JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了。

Cglib动态代理：

cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。

实例：

package cn.spring.cglibporxy;

/**
 * 业务类
 */
public class IService {
    public void doSome(){
        System.out.println("我是实现业务的方法");
    }
}

package cn.spring.cglibporxy;

import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibProxyTest {
    public static void main(String[] args) {
        //CGLIB动态代理（当前项目必须有CGLIB的支持）

        //步骤一：目标对象
        final IService iService=new IService();
        //步骤二：通过CGLIB提供的Enhancer类生成代理
        Enhancer enhancer=new Enhancer();
        //步骤三：指定需要代理的目标对象模板（将目标对象放入到代理工厂当中，生成代理对象）
        enhancer.setSuperclass(iService.getClass());
        //步骤四：实现增强的处理操作
        enhancer.setCallback(new MethodInterceptor() {
            /**
             *
             * @param o             目标对象
             * @param method        目标对象的方法
             * @param objects       目标对象方法内的参数
             * @param methodProxy   代理目标对象方法
             * @return
             * @throws Throwable
             */
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("前置");

                Object invoke = methodProxy.invoke(iService, objects);
                System.out.println("后置");
                return invoke;
            }
        });
        //最后一步：创建代理
        IService iServiceProxy = (IService)enhancer.create();
        iServiceProxy.doSome();
    }
}