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 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,并自动注入
- <bean id="user1" class="com.model.User" autowire="byName">
- <property name="username" value="苦海"></property>
- <property name="password" value="111"></property>
- </bean>
- <bean id="dept" lazy-init="true" class="com.model.Dept" init-method="init" destroy-method="destory" >
- <property name="deptid" value="6001"></property>
- <property name="deptname" value="部门1"></property>
- <property name="users">
- <list>
- <ref bean="user1"/>
- </list>
- </property>
- </bean>
- ApplicationContext ac=new ClassPathXmlApplicationContext("Spring-all.xml");//调用此方法时类已经实例化好了
- User u=(User)ac.getBean("user1");//拿到实例化的类
- System.out.println(u);
- ((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" // 延迟加载,未生效
- 1 < bean id = "dept1"lazy - init = "true"class = "com.model.Dept"init - method = "init"destroy - method = "destory" >
写在beans中,设置全局延迟加载
- 1 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 默认就不是程序初始化的时候实例化的)
来源: http://www.cnblogs.com/jiangwz/p/7595803.html