Spring框架（二）

Spring反射机制：

1, 通过spring来获取一个对象的实例

     <bean id="user" class="com.model.User">

     </bean>

         ApplicationContext ac=new ClassPathXmlApplicationContext("Spring-all.xml");//调用此方法时类已经实例化好了
         User u=(User)ac.getBean("user");//拿到实例化的类

2, 通过spring进行属性注入
　　setter方法注入

     <!-- 通过Spring給类注入属性，通过空参构造方法 -->
         <property name="username">
             <value>hanqi</value>
         </property>
         <property name="password">
             <value>123</value>
         </property>   

　　构造器注入

         <!--
         另一种通过带参构造方法-->
         <constructor-arg index="0" value="name1"></constructor-arg>
         <constructor-arg index="1" value="pwd1"></constructor-arg>
         

　　接口注入

 public class ClassA {
 　　private InterfaceB clzB;
 　　public init() {
 　　Ojbect obj =
 　　Class.forName(Config.BImplementation).newInstance();
 　　clzB = (InterfaceB)obj;
 　　}
 　　……
 　　} 

　　上面的代码中，ClassA依赖于InterfaceB的实现，如何获得InterfaceB实现类的实例？传统的方法是在代码中创建InterfaceB实现类的实例，并将起赋予clzB。

　　而这样一来，ClassA在编译期即依赖于InterfaceB的实现。为了将调用者与实现者在编译期分离，于是有了上面的代码，我们根据预先在配置文件中设定的实现类的类名，动态加载实现类，并通过InterfaceB强制转型后为ClassA所用。
　　这就是接口注入的一个最原始的雏形。
　　而对于一个Type1型IOC容器而言，加载接口实现并创建其实例的工作由容器完成，如J2EE开发中常用的Context.lookup（ServletContext.getXXX），都是Type1型IOC的表现形式。
　　Apache Avalon是一个典型的Type1型IOC容器。

　　p标记的使用
　　<bean p:username=""></bean>

     <bean id="user" class="com.model.User" p:username="pusername" p:password="ppwd">
     </bean>

3, 将一个对象注入到另一个对象<ref bean="...">

用户有一个部门

部门有多个用户

model：

 package com.model;

 public class User {
     private String username;
     private String password;
     private Dept dept;

     public User() {
         super();
         // TODO Auto-generated constructor stub
     }
     public User(String username, String password, Dept dept) {
         super();
         this.username = username;
         this.password = password;
         this.dept = dept;
     }
     public String getUsername() {
         return username;
     }
     public void setUsername(String username) {
         this.username = username;
     }
     public String getPassword() {
         return password;
     }
     public void setPassword(String password) {
         this.password = password;
     }
     public Dept getDept() {
         return dept;
     }
     public void setDept(Dept dept) {
         this.dept = dept;
     }
     @Override
     public String toString() {
         return "User [username=" + username + ", password=" + password + ", dept=" + dept + "]";
     }

 }

 package com.model;

 import java.util.List;

 public class Dept {
     private int deptid;
     private String deptname;
     private List<User> users;

     public Dept() {
         super();
         // TODO Auto-generated constructor stub
     }

     public Dept(int deptid, String deptname, List<User> users) {
         super();
         this.deptid = deptid;
         this.deptname = deptname;
         this.users = users;
     }

     public int getDeptid() {
         return deptid;
     }
     public void setDeptid(int deptid) {
         this.deptid = deptid;
     }
     public String getDeptname() {
         return deptname;
     }
     public void setDeptname(String deptname) {
         this.deptname = deptname;
     }

     public List<User> getUsers() {
         return users;
     }

     public void setUsers(List<User> users) {
         this.users = users;
     }

     @Override
     public String toString() {
         return "Dept [deptid=" + deptid + ", deptname=" + deptname + ", users人数=" + users.size() + "]";
     }

 }

配置文件：

 <?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:p="http://www.springframework.org/schema/p"
     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

     <bean id="user1" class="com.model.User">
         <property name="username" value="苦海"></property>
         <property name="password" value="111"></property>
         <property name="dept" ref="dept1"></property>

     </bean>

     <bean id="dept1" class="com.model.Dept">
         <property name="deptid" value="6001"></property>
         <property name="deptname" value="部门1"></property>
         <property name="users">
             <list>
                 <ref bean="user1"/>
             </list>
         </property>
     </bean>

 </beans>

测试：

 package com.test;

 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.model.Dept;
 import com.model.User;

 public class Test {
     public static void main(String[] args) {
         ApplicationContext ac=new ClassPathXmlApplicationContext("Spring-all.xml");//调用此方法时类已经实例化好了

         User u=(User)ac.getBean("user1");//拿到实例化的类
         Dept d=(Dept)ac.getBean("dept1");

         System.out.println(u);
         System.out.println(d);
         ((ClassPathXmlApplicationContext)ac).close();

     }
 }

4, AutoWired(byType, byName)

　　autowire

自动装载：

byName根据名字自动注入

user1的bean中并没有dept属性，但是还是打印出了这个属性，因为它会找到这个类，然后在配置文件中找到和该属性同名的id，并自动注入

 1     <bean id="user1" class="com.model.User" autowire="byName">
 2         <property name="username" value="苦海"></property>
 3         <property name="password" value="111"></property>
 4     </bean>
 5
 6     <bean id="dept" lazy-init="true" class="com.model.Dept" init-method="init" destroy-method="destory"  >
 7         <property name="deptid" value="6001"></property>
 8         <property name="deptname" value="部门1"></property>
 9         <property name="users">
10             <list>
11                 <ref bean="user1"/>
12             </list>
13         </property>
14     </bean>

1         ApplicationContext ac=new ClassPathXmlApplicationContext("Spring-all.xml");//调用此方法时类已经实例化好了
2         User u=(User)ac.getBean("user1");//拿到实例化的类
3         System.out.println(u);
4         ((ClassPathXmlApplicationContext)ac).close();

byType根据类型自动装载，用法一致

需要注意，如果根据类型自动装载，应只有一个该类型，否则会无发找到，报错

autowire默认default，指的是根据<beans>声明中得来选择方法

5, scope, lazy-init, init-method, destroy-method(相当的不重要)
　　scope="singleton(单例) / prototype(原型)"

默认情况下Spring中定义的Bean是以单例模式创建的。
在GoF中的单例模式是指一个ClassLoader中只存在类一个实例。
而在Spring中的单例实际上更确切的说应该是：
1.每个Spring Container中定义的Bean只存在一个实例
2.每个Bean定义只存在一个实例。

     <bean id="user1" class="com.model.User" scope="singleton">
         <property name="username" value="苦海"></property>
         <property name="password" value="111"></property>
     </bean>

         ApplicationContext ac=new ClassPathXmlApplicationContext("Spring-all.xml");//调用此方法时类已经实例化好了
         User u=(User)ac.getBean("user1");//拿到实例化的类
         User u2=(User)ac.getBean("user1");
         System.out.println(u==u2);
         ((ClassPathXmlApplicationContext)ac).close();

     <bean id="user1" class="com.model.User" scope="prototype">
         <property name="username" value="苦海"></property>
         <property name="password" value="111"></property>
     </bean>

         ApplicationContext ac=new ClassPathXmlApplicationContext("Spring-all.xml");
         User u=(User)ac.getBean("user1");
         User u2=(User)ac.getBean("user1");
         System.out.println(u==u2);
         ((ClassPathXmlApplicationContext)ac).close();

　　lazy-init="true" // 延迟加载，未生效

 <bean id="dept1" lazy-init="true" class="com.model.Dept" init-method="init" destroy-method="destory"  >

写在beans中，设置全局延迟加载

     default-lazy-init="true"

lazy-init    (一开始不初始化，用到的时候才初始化)
    init-method="init" destory-method="destory"    不要和prototype一起使用
类被初始化的时候调用init,被消亡的时候调用destory

正常运行的结果只有一个init和destroy,虽然两个service实例化，但是默认是单例,加了scope=prototype就运行不正常了，结果两个init，没有destroy,原因未知。 
首先我们应该知道：

一、spring Bean的作用域:scope=singleton(默认，单例，生成一个实例）

二、spring Bean的作用域:scope=prototype(多线程, 生成多个实例）

三、单例模式，默认在程序初始化的时候实例化(lazy-init=”false”)

四、prototype，getBean的时候才是实例化

五、lazy-init 只对单例模式起作用，对 prototype 不起作用（因为 prototype 默认就不是程序初始化的时候实例化的）