SpringFramework详解

/**
 * 代理类和被代理类的抽象
 */
interface Person {
    public void byTicket();
}

/**
 * 代理类
 */
public class ZhangshanProxy implements Person {
    private Zhangshan target;

    public ZhangshanProxy(Zhangshan target) {
        this.target = target;
    }

    @Override
    public void byTicket() {
        System.out.print("先查下票看还有没得...");
        target.byTicket();
        System.out.print("购买成功了...");
    }
}

/**
 * 被代理类
 */
public class Zhangshan implements Person {
    @Override
    public void byTicket() {
        System.out.print("张山买票...");
    }
}

public class StartApp {
    public static void main(String[] args) {
        /*
         * 调用者直接调用代理类，而不直接调用被代理的类
         */
        Person p = new ZhangshanProxy(new Zhangshan());
        p.byTicket();
    }
}

/**
 * 被代理类的抽象
 */
interface Person {
    public void byTicket();
}

/**
 * 被代理类
 */
public class Zhangshan implements Person {
    @Override
    public void byTicket() {
        System.out.print("张山买票...");
    }
}

/**
 * 代理类：不一定只代理Zhangshan
 */
public class ByTicketProxy implements InvocationHandler {
    private Object target;

    public ByTicketProxy(Object target) {
        this.target = target;
    }
    
    /**
     * InvocationHandler只有一个invoke方法，它是所有被代理对象的所有方法的唯一实现。
     * 也就是说：无论调用被代理对象的任何方法，最终都是调用该invoke方法
     * proxy是代理对象
     * method参数是被调用的方法的反射对象
     * args参数是被调用时传入的参数数组
     * 返回值是当前被调用的方法的返回值
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.print("先查下票看还有没得...");
        // 反射调用target对象的method方法
        Object res = method.invoke(target, args);
        System.out.print("购买成功了...");
        return res;
    }
}

public class StartApp {
    public static void main(String[] args) {
        /*
         * 1、获取代理类 2、获取代理类的构造器 3、使用构造器创建一个实例 4、调用实例的方法
         */
        Class<?> calss = Proxy.getProxyClass(Person.class.getClassLoader(), Person.class);
        Constructor<?> constructor = calss.getConstructor(InvocationHandler.class);
        InvocationHandler handler = new ByTicketProxy(new Zhangshan());
        Person person = (Person) constructor.newInstance(handler);
        person.byTicket();// 调用目标对象方法时会触发事件处理器的方法，把当前目标方法作为参数传入
    }
}

public class ITest {

    public static void main(String[] args) {

        //被观察者
        MySubject subject = new MySubject();

        //注册观察者==添加监听器
        subject.registerObserver(new MyObserver("zhangshan"));
        subject.registerObserver(new MyObserver("lisi"));
        subject.registerObserver(new MyObserver("wangwu"));
        subject.registerObserver(new MyObserver("zhaoliu"));

        //被观察者执行操作==触发事件
        subject.setMessage("hi, happy new year!");
    }
}


/**
 * 观察者接口：观察者将提供一个用于被观察者调用的方法
 */
public interface IObserver {

    /**
     * 观察者方法
     * @param message  被观察者传递的对象 == 事件对象
     */
    public void invoke(Object message);
}

/**
 * 被观察者接口 : 提供注册观察者的方法，提供通知观察者的方法
 */
public interface ISubject {
    /**
     * 注册观察者：事件订阅
     *
     * @param observer
     */
    public void registerObserver(IObserver observer);

    /**
     * 移除观察者：取消订阅
     *
     * @param observer
     */
    public void removeObserver(IObserver observer);

    /**
     * 通知所有观察者：事件触发
     */
    public void sendToObservers();
}


/**
 * 具体观察者
 */
public class MyObserver implements IObserver {

    private String name;

    public MyObserver(String name) {
        this.name = name;
    }

    @Override
    public void invoke(Object message) {
        System.out.println(this.name + " receiver message:" + message);
    }
}


/**
 * 具体被观察者
 */
public class MySubject implements  ISubject {

    /**
     * 观察者集合
     */
    private List<IObserver> observers = new ArrayList();

    private Object message;

    /**
     * 触发通知==事件触发
     * @param message
     */
    public void setMessage(Object message) {
        this.message = message;
        sendToObservers();
    }

    @Override
    public void registerObserver(IObserver observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(IObserver observer) {
        observers.remove(observer);
    }

    @Override
    public void sendToObservers() {
        for (IObserver item : observers) {
            item.invoke(this.message);
        }
    }
}

/**
 * bean的后置处理器类
 */
public class MyBeanPostProcessor implements BeanPostProcessor {
    /**
     * *
     * 该重写方法将在生命周期的init-method方法之前执行
     *
     * @param bean     bean对象
     * @param beanName bean名称
     * @return bean对象  这个对象可以是原始对象也可以是被修改后的bean对象
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("MyBeanPostProcessor后置处理器在init-method之前执行了...");
        return bean;
    }

    /**
     * *
     * 该重写方法将在生命周期的init-method方法之后执行
     *
     * @param bean     bean对象
     * @param beanName bean名称
     * @return bean对象 这个对象可以是原始对象也可以是被修改后的bean对象
     * @throws BeansException
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("MyBeanPostProcessor后置处理器在init-method之后执行了...");
        return bean;
    }
}

 /**
     * 从xml配置文件中读取信息，来管理和实例化bean对象
     */
    public static void newBeanByconfigxml() {
        //ApplicationContex接口有多个实现，此处通过ClassPathXmlApplicationContext对象来加载配置文件
        //实例化Spring容器，把容器中管理的bean实例创建并存储到Map集合中
        //注意:创建对象时会调用默认的无参构造函数，如果在对象中定义了有参构造函数，则默认的无参构造函数不会自定生成，需要手动创建一个默认的无参构造函数
        //在非web应用程序中初始化IOC是直接在main方法实例化如下对象，在web网站中应该在web应用程序被服务器加载时就实例化IOC容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("context_config.xml");

        //打印出map集合中被创建的bean，先获取所有bean的名称
        String[] beans = ctx.getBeanDefinitionNames();
        for (String bean : beans) {
            System.out.println(bean + " of Type :: " + ctx.getBean(bean).getClass());
        }
}

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">
  <!--  该文件为Spring配置文件， 通过以下节点配置Bean，容器工厂将通过这些配置来动态生成Bean对象-->

    <!-- 一个最简单的bean配置,该配置将通过默认无参构造函数来创建实例，value指定的值为实例属性的默认初始值，spring是通过属性的setter方法来注入值的【属性注入】-->
   <bean id="zhangshan"  class="com.zqh.entity.User">
       <property name="id" value="1"/>
       <property name="userName" value="zhangshan"/>
       <property name="realName" value="张山"/>
       <property name="deptId" value="1"/>
       <property name="postId" value="1"/>
       <property name="phone" value="15000000000"/>
       <property name="remark" value="我是通过简单的属性注入的"/>
       <!-- 赋值null专用写法-->
       <!-- <constructor-arg type="java.lang.Integer" > <null/></constructor-arg> -->
   </bean>

    <!--  带参数的构造方式: constructor-args属性用于配置参数的value,可通过 index、name、type属性来指定，spring是通过传入参数值来注入的【构造函数注入】
     1、如果使用type指定,当参数类型一样时将按照顺序依次赋值，不一样时将按照type对应赋值
     2、如果使用name指定，则按照name名称对应赋值
     3、如果使用index执行，则按照index下标对应赋值
     4、可以使用混合方式指定，但不推荐
     -->
    <bean  name="lisi" class="com.zqh.entity.User">
        <constructor-arg name="userName"  value="lisi"/>
        <constructor-arg name="realName"  value="李四"/>
    </bean>
    <bean  name="wangwu" class="com.zqh.entity.User">
        <constructor-arg index="0"  value="wangwu"/>
        <constructor-arg index="1"  value="王五"/>
    </bean>
    <bean  name="zhaoliu" class="com.zqh.entity.User">
        <constructor-arg type="java.lang.Integer" value="4"/>
        <constructor-arg type="java.lang.String" value="zhaoliu"/>
        <constructor-arg type="java.lang.String" value="赵六"/>
    </bean>

    <!-- property的参数： name表示属性名称，value表示属性值，ref表示引用另一个bean实例
      property使用ref注入对象时:  name表示类中带有setter方法的属性， ref表示引用spring容器中key=wanglaoshi的bean实例
    -->
    <bean  name="xiaomin" class="com.zqh.entity.User">
        <property name="deptDes" ref="dept"/>
        <property name="userName" value="xiaomin"/>
        <property name="realName" value="小明"/>
    </bean>
    <bean  name="dept" class="com.zqh.entity.Dept">
        <property name="deptName" value="研发四部"/>
        <property name="id" value="4"/>
        <property name="parentId" value="1"/>
    </bean>

    <!-- 自动装配 autowire：根据bean的类型或名称进行装配,自动装配会装配bean的所有属性.如果未装配成功则为null。
      1、byName：根据 bean的名字和当前bean的 setter风格的属性名进行自动装配，若有匹配的，则进行自动装配，若没有匹配的，则不装配。【必须将目标Bean 的名称和属性名设置的完全相同。】
      2、byType：通过当前bean的属性的类型来自动查找相应的类型并装配。【若IOC容器中有多个与目标Bean类型一致的Bean.在这种情况下,Spring将无法判定哪个Bean最合适该属性,所以不能执行自动装配】
    -->
    <bean name="damin" class="com.zqh.entity.User" autowire="byType"/> <!-- 该对象中属性deptDes的类型Dept存在对应的bean，被装配 -->
    <bean name="dashuai" class="com.zqh.entity.User" autowire="byName"/> <!-- 该对象中属性deptDes的名称没有对应的bean，不被装配 -->

    <!--  bean的继承：使用子bean的parent属性可以指定要继承的父bean：
      1、Spring允许继承bean的配置,被继承的bean称为父bean，继承这个父Bean 的 Bean称为子Bean。
      2、子Bean从父Bean中继承配置,包括Bean的属性配置。
      3、子Bean也可以覆盖从父Bean继承过来的配置。
      4、父Bean可以作为配置模板,也可以作为Bean实例，若只想把父Bean作为模板,可以设置<bean>的abstract属性为true,这样Spring将不会实例化这个Bean。
      5、并不是<bean>元素里的所有属性都会被继承，比如: autowire,abstract等。
      6、可以忽略父Bean的class属性,让子Bean指定自己的类,而共享相同的属性配置，但此时abstrac必须设为true。
    -->
    <bean name="zhangshan1" class="com.zqh.entity.User" parent="zhangshan" /> <!--  继承了名为zhanshan的父bean的配置-->

    <!--  bean的作用域：通过bean的scope属性可以指定bean的作用域：
      1、prototype：每次需要bean时，容器都会产生一个新的bean。
      2、request：用于域对象的request(不常用)。
      3、session：用于域对象的session(不常用)。
      4、singleton：默认值,单例模式-容器初始化时创建的bean实例，将应用在整个生命周期中。
    -->
    <bean name="zhangshan2" class="com.zqh.entity.User" autowire="byName" scope="prototype"/>

    <!-- 使用spring表达式语言 spel 为bean进行动态赋值 ：使用 #{}作为界定符号，除了基本el运算，还可以引用bean、属性和方法等 -->
    <bean  name="zhangsanfeng" class="com.zqh.entity.User">
        <property name="deptDes" ref="dept"/>
        <property name="userName" value='#{ "zhangshanfeng" }'/> <!--赋值一个字符串 -->
        <property name="postId" value='#{108}'/><!--赋值一个数字 -->
    </bean>

    <!-- SpringIOC容器可以管理bean的生命周期，Spring在bean生命周期的特定点执行方法：
      IOD管理bean的过程：
      1、调用构造器或者工厂方法创建bean实例
      2、设置bean的属性默认值和其他bean的引用
      3、调用bean的初始化方法：init-method
      4、bean的使用
      5、关闭容器时销毁bean，同时会调用destroy-method方法
     -->
    <bean name="zhangjunbao" class="com.zqh.entity.User" init-method="init" destroy-method="close"><!--指定生命周期方法 -->
        <property name="deptDes" ref="dept"/>
        <property name="userName" value="zhangjunbao"/>
        <property name="realName" value="张君宝"/>
    </bean>

   <!--   bean的后置处理器：后置处理器用于在bean的生命周期特定阶段对bean执行特定的操作，声明一个后置处理器的方式是实现BeanPostProcessor接口，并具体提供如下方法的实现：
            1、  Object postProcessBeforeInitialization(Object bean, String beanName )
            2、  Object postProcessAfterInitialization(Object bean, String beanName)
         第一个方法将在init-method之前被调用，第二个方法将在init-method之后被调用，
    -->
    <!--配置bean的后置处理器:不需要配置id,IOC 容器自动识别是一个BeanPostProcessor后置处理器 -->
    <bean class="com.zqh.MyBeanPostProcessor"> </bean>

    <!--  通过静态工厂方法来配置bean：
        class属性:指向静态工厂方法的全类名
        factory-method:指向静态工厂方法的名字，如果方法需要参数，则通过constructor-arg注入
    -->
    <bean id="lijiachen" class="com.zqh.UserStaticBeanFactory" factory-method="getUser">
        <constructor-arg name="name"  value="lijiachen"/>
    </bean>

    <!--  通过实例工厂方法来配置bean：首先要配置实例工厂bean，其次通过factory-bean指定实例工厂bean，factory-method指定实例工厂的方法-->
          <!--配置工厂bean实例 -->
    <bean id="factory" class="com.zqh.UserInsBeanFactory" ></bean>

    <!--实例方法配置bean，需指定实例工厂bean和对应的方法
        factory-bean:指向实例工厂的bean
        factory-method:指向实例工厂方法的名字，如果方法需要参数，则通过constructor-arg注入
        -->
    <bean id="liyifeng" factory-bean="factory" factory-method="getUser">
        <constructor-arg name="name"  value="liyifeng"/>
    </bean>

    <!--  通过Spring自带的FactoryBean来配置bean： 只需要通过class指定FactoryBean实例类即可-->
    <bean id="zhangwuji" class="com.zqh.UserFactoryBean" ></bean>

</beans>

　/**
　　1、在非web应用程序中初始化IOC是直接在main方法实例化如下对象，在web网站中应该在web应用程序被服务器加载时就实例化IOC容器。
　　2、ApplicationContex接口有多个实现，此处通过ClassPathXmlApplicationContext对象来创建Bean。
　　3、创建对象时会调用默认的无参构造函数，如果在对象中定义了有参构造函数，则默认的无参构造函数不会自定生成，需要手动创建一个默认的无参构造函数。
　　*/
        ApplicationContext ctx = new ClassPathXmlApplicationContext("context_config.xml");

　　//打印出map集合中被创建的bean信息
        String[] beans = ctx.getBeanDefinitionNames();
        for (String bean : beans) {
            System.out.println(bean + " of Type :: " + ctx.getBean(bean).getClass());
        }

   //获取bean对象
  User zhangshan = (User) ctx.getBean("zhangshan");

<?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
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <!--导入属性文件，导入该配置需要引入context命名空间，引入方式是配置：
      xmlns:context = "http://www.springframework.org/schema/context"
       xsi:schemaLocation = http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
     -->

  <!-- 指定Spring IOC容器扫描的包，这些包下的被@Component、@Controller、@Service、@Repository注解了的bean会被IOC自动扫描并配置:
      base-package:指定被扫描的包，多个包时使用英文逗号分割
      resource-pattern:正则匹配，只扫面在base-package指定的包下被匹配的bean文件
      use-default-filters: 默认值true，指示是否使用默认的过滤规则，如果为false，则使用include-filter、exclude-filter指定的filter
   -->
    <context:component-scan base-package="com.zqh"  use-default-filters="false">

        <!--  指示要被包含的目标类型，component-scan下可以拥有多个该子节点：expression表示过滤器表达式，type属性表示过滤器表达式的类型，有如下几种：
          1、annotation：目标类是否标注了某个注解来进行过滤
          2、assignable：目标类是否继承或扩展了某个特定类来进行过滤
          3、aspectj：目标类是否满足指定命名规则或扩展自该命名规则的类来进行过滤
          4、regex：目标类的包名是否满足指定正则规则来进行过滤
          5、custom：通过指定的filter过滤器来进行过滤，该过滤器必须实现 org.springframework.core.type.filter.TypeFilter 接口
        -->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/>
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Component"/>

        <!--  指示要排除的目标类，component-scan下可以拥有多个该子节点：属性与include-filter属性一致 -->
        <!--  <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Component"/> -->
</context:component-scan>




</beans>