一、心动不如行动
一、创建项目
*注:在IDEA中我创建的Maven项目,不了解Maven的朋友可以看我之前的博客“我们一起走进Maven——知己知彼”,了解Maven后可以看我之前的博客“Maven的安装与配置”,自行安装,行动起来吧。
二、加载依赖
在pom.xml文件中添加Spring依赖和日志相关依赖
junit junit 4.11 test org.springframework spring-core 5.0.2.RELEASE org.springframework spring-context 5.0.2.RELEASE org.springframework spring-beans 5.0.2.RELEASE org.springframework spring-expression 5.0.2.RELEASE commons-logging commons-logging 1.2 log4j log4j 1.2.17
三、项目结构
在main目录下面创建java和resources目录
四、基础代码实现(练手)
- 创建TestDao接口和实现类
- 获得TestDao实现类的实例
- 在之前开发中,我们是直接new一个对象即可。即:`private TestDao dao = new TestDaoImpl();`
- 在学习Spring之后,将由Spring来创建对象的实例 --> 即:`IoC 控制反转(Inverse of Control)`
之后需要实例对象时,从Spring工厂(容器)中获得即可,需要将实现类的全限定名称配置到xml文件中。
创建dao包,在dao包下创建TestDao接口和TestDao接口的实现类,结构如下图:
TestDao接口代码示例:
package dao; public interface TestDao { public void sayHello(); }
TestDaoImpl实现类代码示例:
package dao; public class TestDaoImpl implements TestDao{ @Override public void sayHello() { System.out.println("Hello,Spring!"); } }
在resources资源目录点击右键,依次选择New-->XML Configuration File-->Spring Config,创建applicationContext.xml的配置文件
创建test包,在test包下创建测试类SpringTest
package test;
import dao.TestDao; import org.junit.jupiter.api.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class SpringTest {
@Test
public void demo1(){
// 之前开发,自己手写new出对象
TestDao dao= new TestDaoImpl();
dao.sayHello();
}
@Test
public void demo2() {
// 现在从spring容器中获得对象实例
// 1 、获得容器
//初始化Spring容器ApplicationContext,加载配置文件
ApplicationContext application = new ClassPathXmlApplicationContext("applicationContext.xml");
// 2、获得内容 ,注意此时不需要自己new出对象了,都是从spring容器中获得
//通过容器获取testDao实例
TestDao testDao = (TestDao) application.getBean("testDao");
testDao.sayHello();
}
}
- IoC(Inverse of Control)反转控制的概念,就是将原本在程序中手动创建TestDaoImpl对象的控制权,交由Spring框架管理。
- 简单说,就是创建TestDaoImpl对象的控制权被反转到了Spring框架。
点击测试方法左侧的运行按钮,选择Run,测试代码
运行后控制台显示结果
项目运行成功!!!!!!!
五、Spring入门案例:DI(掌握)
- DI :Dependency Injection :依赖注入
- is a :是一个,继承。
- has a:有一个,成员变量,依赖。
class B { private A a; // B类依赖A类,B类使用A类。 } 依赖:一个对象需要使用另一个对象。 注入:通过setter方法进行另一个对象实例设置。
例如:
class BookServiceImpl { // 之前开发:接口 = 实现类(service和dao耦合了,写死了,知道具体的实现类是谁,那么我的具体实现类变化,那么这行代码也得跟着变) // private BookDao bookDao = new BookDaoImpl(); // spring之后(解耦:service实现类使用了dao的接口,这样就不知道具体的实现类是谁了) private BookDao bookDao; setter方法 } 模拟spring执行过程 创建service实例:BookService bookService = new BookServiceImpl(); => IoC创建dao实例:BookDao bookDao = new BookDaoImple(); => IoC 将dao设置给service:bookService.setBookDao(bookDao); => DI
具体代码实现:
实现步骤:
- 创建BookDao接口和实现类
- 创建BookService接口和实现类
- 将dao和service配置到 applicationContext.xml文件中
- 使用api测试
项目结构:
加载依赖:
在pom.xml文件中添加Spring依赖和日志相关依赖
junit junit 4.11 test org.springframework spring-core 5.0.2.RELEASE org.springframework spring-context 5.0.2.RELEASE org.springframework spring-beans 5.0.2.RELEASE org.springframework spring-expression 5.0.2.RELEASE commons-logging commons-logging 1.2 log4j log4j 1.2.17
BookDao接口和实现类
package dao; public interface BookDao { void save(); }
package dao; public class BookDaoImpl implements BookDao { @Override public void save() { System.out.println("实现添加功能"); } }
BookService接口和实现类
package Service; public interface BookService { void addBook(); }
package Service; import dao.BookDao; import dao.BookDaoImpl; public class BookServiceImpl implements BookService { //方式一:之前,接口=实现类 //private BookDao bookDao= new BookDaoImpl(); //方式二:现在,接口+setter方法 private BookDao bookDao; public void setBookDao(BookDao bookDao){ this.bookDao=bookDao; } @Override public void addBook() { this.bookDao.save(); } }
将dao和service配置到 applicationContext.xml文件中
使用api测试
创建test包,在test包下创建测试类SpringTest
package test; import Service.BookService; import org.junit.jupiter.api.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class SpringTest { @Test public void Test1(){ // 之前开发,自己手写new出对象 // BookService bookService = new BookServiceImpl(); // bookService.addBook(); } @Test public void Test2(){ // 现在从spring容器中获得对象实例 // 1 、获得容器 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); // 2、获得内容 ,注意此时不需要自己new出对象了,都是从spring容器中获得 BookService bookService = (BookService) applicationContext.getBean("bookServiceId"); bookService.addBook(); } }
- DI:Dependency Injection 依赖注入,在Spring框架负责创建Bean对象时,动态的将依赖对象注入到Bean组件。
- getBean("bookServiceId"); 从spring容器中获得指定名称对象的实例时,会先判断本实例对象是否需要使用其他实例化对象,由于设置了< property name="bookDao" ref="bookDaoId">< /property>,说明需要使用其他实例化对象,所以就根据其他Bean的id值的引用,去spring容器中获得指定名称对象的实例,相当于将dao实例设置给service实例。
运行后控制台显示结果
这就成功了,开心一下,通过这两个案例,多Spring有了初步的理解,加油!
六、Spring的核心API(了解)
api整体了解即可,之后不使用,在学习过程需要。
- BeanFactory :这是一个
工厂
,用于生成任意Bean。采取延迟加载,第一次调用getBean(); 时才会初始化Bean。(即实例化对象)
- ApplicationContext :是BeanFactory的子接口,功能更强大。(国际化处理、事件传递、Bean自动装配、各种不同应用层的Context实现)。
采取非延时加载,当配置文件被加载时,就进行对象的实例化。
- ClassPathXmlApplicationContext 用于加载classpath(类路径/src)下的xml
- 加载xml运行时位置 --> /WEB-INF/classes/xxx.xml
- FileSystemXmlApplicationContext 用于加载指定盘符下的xml
- 加载xml运行时位置 --> /WEB-INF/xxx.xml
- 通过java web学习过的 ServletContext.getRealPath(); 获得具体盘符
- ClassPathXmlApplicationContext 用于加载classpath(类路径/src)下的xml
示例代码如下:
package test; import Service.BookService; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.xml.XmlBeanFactory; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import org.springframework.core.io.ClassPathResource; public class SpringTest { @Test public void Test1(){ // 之前开发,自己手写new出对象 // BookService bookService = new BookServiceImpl(); // bookService.addBook(); } @Test public void Test2(){ // 现在从spring容器中获得对象实例 // 1 、获得容器 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); // 采取非延时加载,当配置文件被加载时,就进行对象的实例化。 // 2、获得内容 ,注意此时不需要自己new出对象了,都是从spring容器中获得 BookService bookService = (BookService) applicationContext.getBean("bookServiceId"); bookService.addBook(); } @Test public void demo3() { // 现在从spring容器中获得对象实例,使用的是BeanFactory,里面需要一个Resource,该Resource又是一个接口,需要找它的实现类ClassPathResource // 1 、获得容器 BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml")); // 2、获得内容 ,注意此时不需要自己new出对象了,都是从spring容器中获得 BookService bookService = (BookService) beanFactory.getBean("bookServiceId"); // 采取延迟加载,第一次调用getBean(); 时才会初始化Bean(即实例化对象)。 bookService.addBook(); } }
七、装配Bean:基于XML
3种bean实例化方式:
- 使用`默认构造方法`实例化
- 使用`静态工厂方法`实例化
- 使用`实例工厂方法`实例化
使用默认构造方法实例化
格式:
例如:
示例中用到的 UserService.java 和 UserServiceImpl.java 代码同上面实例中的代码,这里不再赘述!
在spring容器中进行配置:
applicationContext.xml
<bean id="userServiceId" class="Service.UserServiceImpl">bean>
测试代码:
public class TestIoC { @Test public void demo01() { // 之前开发,自己手写new出对象 UserService userService = new UserServiceImpl(); // 直接手动创建实例 userService.addUser(); } @Test public void demo02() { // 现在从spring容器中获得对象实例 // 1 、获得容器 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); // 2、获得内容 ,注意此时不需要自己new出对象了,都是从spring容器中获得 UserService userService = (UserService) applicationContext.getBean("userServiceId"); userService.addUser(); } }
使用`静态工厂方法`实例化
- 静态工厂:常用与spring整合其他框架(工具)时。
- 静态工厂:用于生成实例对象,所有的方法必须是static。
示例中用到的 UserService.java 和 UserServiceImpl.java 代码同上面实例中的代码,这里不再赘述!
格式:
在spring容器中进行配置:
applicationContext.xml
<bean id="userServiceId" class="Service.MyBeanFactory" factory-method="createService">bean>
静态工厂类代码:
public class MyBeanFactory { /** * 创建实例的静态工厂,所有的方法必须是静态的(static)。 * * @return */ public static UserService createService() { return new UserServiceImpl(); } // 还有创建其他实例的静态工厂 // ...... }
测试代码:
TestStaticFactory.java
/** * 第二种实例化Bean 的方式 :使用静态工厂方法实例化 * */ public class TestStaticFactory { @Test public void demo01() { // 以前:使用自定义的静态实例工厂 UserService userService = MyBeanFactory.createService(); userService.addUser(); } @Test public void demo02() { // 现在:使用spring 工厂:将自定义的静态工厂创建的实例交给spring管理
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = applicationContext.getBean("userServiceId", UserService.class); // 这种方式底层会自动转换
// UserService userService = (UserService) applicationContext.getBean("userServiceId");
userService.addUser();
}
}
注意:当使用JDK版本为1.8时,运行上面的测试代码会出现一个问题: java.lang.IllegalArgumentException,
问题解决链接:使用Junit测试一个 spring静态工厂实例化bean 的例子,所有代码都没有问题,但是出现java.lang.IllegalArgumentException异常
小结:在以后的开发中,工厂类不需要我们去手写,因为别人已经写好了,我们通过编写配置文件
,把别人写好的工厂类拿来,写上要用的方法名,然后把它生产后的实例给Spring存起来,以后我们要用什么实例,跟Spring说一下,去拿就可以了。
使用`实例工厂方法`实例化
实例工厂:必须先有工厂的实例对象,然后通过实例对象去创建对象。特点:提供所有的方法都是“非静态”的。
示例中用到的 UserService.java 和 UserServiceImpl.java 代码同上面实例中的代码,这里不再赘述!
在spring容器中进行配置:
applicationContext.xml
<bean id="myBeanFactoryId" class="com.itheima.c_inject.c_factory.MyBeanFactory" >bean>
<bean id="userServiceId" factory-bean="myBeanFactoryId" factory-method="createService">bean>
静态工厂类代码:
public class MyBeanFactory { /** * 创建实例的工厂,所有方法非静态 * * @return */ public UserService createService() { return new UserServiceImpl(); } // 还有创建其他实例的工厂 // ...... }
测试代码:
TestFactory.java
package test; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; /** * 第三种实例化Bean 的方式 :使用实例工厂方法实例化 * */ public class TestFactory { @Test public void demo01() { // 以前:使用自定义的实例工厂 // 1、创建工厂实例 MyBeanFactory myBeanFactory = new MyBeanFactory(); // 2、通过工厂实例,获得对象 UserService userService = myBeanFactory.createService(); userService.addUser(); } @Test public void demo02() { // 现在:使用spring 工厂:将自定义的实例工厂创建的实例交给spring管理
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = applicationContext.getBean("userServiceId", UserService.class); // 这种方式底层会自动转换
// UserService userService = (UserService) applicationContext.getBean("userServiceId");
userService.addUser();
}
}
-
一、Bean的种类
-
普通bean :之前操作的都是普通bean。例如:
< bean id="xxx" class="A" >
,这句代码的意思是:Spring直接创建A的实例,并返回。 -
FactoryBean :是一个特殊的bean,
具有工厂生成对象能力
,但是只能生成特定的对象。
想要生产对象的bean 必须实现FactoryBean 接口,此接口提供方法getObject(); 用于获得特定bean。- 示例:
< bean id="xxx" class="FB">
,这句代码的意思是:Spring会先创建FB实例,然后调用getObject(); 方法,并返回方法的返回值。
即相当于如下两行代码:
FB fb = new FB();
return fb.getObject();
- 示例:
-
BeanFactory 和 FactoryBean 对比?
- BeanFactory :是一个生产bean的工厂,用于生成任意的bean。
- FactoryBean :是一个特殊的bean,用于生成另一个特定的bean。
- 例如:ProxyFactoryBean ,此工厂bean用于生产代理对象的实例。
< bean id="xxx" class="….ProxyFactoryBean">
,这句代码的意思是:获得代理对象的实例。即AOP使用。
- 例如:ProxyFactoryBean ,此工厂bean用于生产代理对象的实例。
-
spring容器中bean元素id和name属性的区别?
-
在spring容器中添加以下配置:
示例:< bean id="userServiceId" class="com.itheima.a_ioc.UserServiceImpl">
-
bean节点中id和name的区别:
-
区别一:
- id : 指定唯一实例引用
- name : 可以指定多个实例引用,例如name="名称1, 名称2"
-
区别二:
-
id :id的命名要满足XML对ID属性命名规范
例如:必须以字母开始,可以使用字母、数字、连字符、下划线、句话、冒号 -
name : 如果Bean的名称中含有特殊字符,就需要使用name属性
例如 :< bean name="# boy" class="cn.itheima.ioc.Boy"/>
-
因为name属性可以相同,所以后出现Bean会覆盖之前出现的同名的Bean。
-
总结:项目开发的时候,强烈要求用id,因为id可以表示唯一引用。
-
-
-
二、Bean的作用域
Bean 的作用域:用于确定spring所创建bean 的实例个数。
- 取值:
- singleton 单例,默认值。
- prototype 多例,每执行一次getBean() 将获得一个实例。例如:在struts整合spring时,需要配置action为多例。
- 配置示例:默认情况下会在容器启动时初始化bean,但我们可以指定Bean节点的
lazy-init="true"
来延迟初始化bean,这时候,只有第一次获取bean会才初始化bean。- 例如:`< bean id="xxx" class="xxx" scope="xxx">`
例如:< bean id="xxx" class="service.UserServiceImpl" lazy-init="true">
- 如果想对所有bean都应用延迟初始化,可以在根节点beans设置
default-lazy-init="true"
,
例如:< beans default-lazy-init="true“>
- Portlet是基于java的web组件,由portlet容器管理,并由容器处理请求,生产动态内容。
- Portals使用portlets作为可插拔用户接口组件,提供信息系统的表示层。
- 作为利用servlets进行web应用编程的下一步,portlets实现了web应用的模块化和用户中心化。
在spring容器中进行配置:
applicationContext.xml
<bean id="userServiceId" class="com.itheima.d_scope.UserServiceImpl" scope="prototype">bean>
测试代码:
TestScope.java
public class TestScope { @Test public void demo01() { // 现在:使用spring 工厂
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService1 = applicationContext.getBean("userServiceId", UserService.class);
// 这种方式底层会自动转换
UserService userService2 = applicationContext.getBean("userServiceId", UserService.class);
// 这种方式底层会自动转换
// 默认Bean的作用域是单例,所以打印的对象的地址是一样的
// System.out.println(userService1); // service.UserServiceImpl@2ac273d3
// System.out.println(userService2); // service.UserServiceImpl@2ac273d3
// 现在在配置文件中添加scope属性,值为prototype,此时Bean的作用域变为多例了,再次打印,输出地址不一样了
System.out.println(userService1);
//service.UserServiceImpl@66480dd7
System.out.println(userService2);
//service.UserServiceImpl@52a86356
}
}
-
三、Bean的生命周期
Bean 的生命周期详情
- instantiate bean 对象实例化。
- populate properties 封装属性。
- 如果Bean实现 BeanNameAware,则表示执行
setBeanName
。 - 如果Bean实现 BeanFactoryAware 或者 ApplicationContextAware,则表示设置实例工厂(
setBeanFactory
)或者上下文对象(setApplicationContext
)。 - 如果存在类实现 BeanPostProcessor(后处理Bean),则表示执行
postProcessBeforeInitialization
。 - 如果Bean实现 InitializingBean,则表示执行
afterPropertiesSet
。 - 调用
,则表示指定初始化方法
init
。 - 如果存在类实现 BeanPostProcessor(处理Bean),则表示执行
postProcessAfterInitialization
。 - 执行业务处理
- 如果Bean实现 DisposableBean,则表示执行
destroy
。 - 调用
,则表示指定销毁方法
customerDestroy
。
-
四、Bean 的初始化和销毁
目标方法执行前和执行后,将进行Bean的初始化或销毁。
示例:
示例代码如下:
编写目标类代码:
UserService.java
public interface UserService { void addUser(); }
UserServiceImpl.java
public class UserServiceImpl implements UserService { @Override public void addUser() { System.out.println("e_lifecycle add user"); } public void myInit() { System.out.println("我的初始化方法"); } public void myDestory() { System.out.println("我的销毁方法"); } }
在spring容器中进行配置:
applicationContext.xml
<bean id="userServiceId" class="service.UserServiceImpl"
init-method="myInit" destroy-method="myDestory">bean>
编写测试代码:
public class TestLifecycle { @Test public void demo01() throws Exception { // 现在:使用spring 工厂(spring 容器)
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) applicationContext.getBean("userServiceId");
userService.addUser(); // 要想使我的销毁方法也执行,必须要求:
// 1.容器必须先close,我的销毁方法才会执行;
// 2.必须是单例的(spring所创建该bean的实例个数只有一个)即bean中的scope配置成默认即可。
// 因为此close方法在接口 ApplicationContext 中没有定义,而在实现类中提供了该方法,我们可以使用反射,因为反射最后执行的就是实现类中的方法。
applicationContext.getClass().getMethod("close").invoke(applicationContext); } }
-
五、BeanPostProcessor 后处理Bean
- 是由spring提供的一种机制,只要实现类实现此接口BeanPostProcessor,并将该实现类提供给spring容器,spring容器将自动执行两个方法:在初始化方法前执行before()方法,在初始化方法后执行after()方法。配置格式:
这句代码的意思就是:把实现类提供给了spring容器。
- Factory hook(勾子) that allows for custom modification of new bean instances, e.g. checking for marker interfaces or wrapping them with proxies.
- spring提供工厂勾子,用于修改实例对象,可以生成代理对象。(是AOP底层)
谷歌翻译:Factory hook(勾子),允许自定义修改新的bean实例,例如:检查标记接口或用代理包装它们。
我们来模拟这句话的意思:
before() => postProcessAfterInitialization(Object bean, String beanName) after() => postProcessBeforeInitialization(Object bean, String beanName) A a = new A(); a = B.before(a); // 将a的实例对象传递给后处理bean,可以什么都没做,也可以做一些事情,比如:生成jdk代理对象并返回给a,这样a就从实例对象变成代理对象了,此时的a就具有了AOP功能;再比如,如果把null返回给a,再用a去调用方法,就会出现空指针异常。 a.init(); a = B.after(a); // 以下是AOP演示: // 我们现在在后处理Bean 代码执行完之后,把jdk代理对象返回给a。让a在调用addUser()之前先做一些事情 // 之前要做的事情 a.addUser(); // 在目标方法的前后可以做一些事情,例如:开启事务、提交事务、性能监控(前后时间)等等 // 之后要做的事情 a.destroy();
目标类示例代码如下:
UserService.java
public interface UserService { void addUser(); }
UserServiceImpl.java
public class UserServiceImpl implements UserService { @Override public void addUser() { System.out.println("e_lifecycle add user"); } public void myInit() { System.out.println("我的初始化方法"); } public void myDestory() { System.out.println("我的销毁方法"); } }
实现类示例代码如下:
MyBeanPostProcessor.java
public class MyBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println("执行了前方法:" + beanName); return bean; } @Override public Object postProcessAfterInitialization(final Object bean, String beanName) throws BeansException { System.out.println("执行了后方法:" + beanName); // 传入的参数bean是我们的目标对象,此时我们的目标对象只有一个接口,那么我们的代理对象也只有一个接口 // 生成jdk代理对象 return Proxy.newProxyInstance( MyBeanPostProcessor.class.getClassLoader(), // 代理对象 bean.getClass().getInterfaces(), // 目标对象 new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("---开启事务---"); Object obj = method.invoke(bean, args); // 执行目标方法,本例中的目标方法是addUser System.out.println("---关闭事务---"); return obj; } }); // 代理的处理程序 } }
在spring容器中进行配置:
applicationContext.xml
<bean id="userServiceId" class="service.UserServiceImpl"
init-method="myInit" destroy-method="myDestory">bean>
<bean class="com.itheima.e_lifecycle.MyBeanPostProcessor">bean>
测试示例代码如下:
TestLifecycle.java
public class TestLifecycle { @Test public void demo01() throws Exception { // 现在:使用spring 工厂(spring 容器) ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) applicationContext.getBean("userServiceId");
userService.addUser();
// 要想使我的销毁方法也执行,必须要求:
// 1.容器必须先close,我的销毁方法才会执行;
// 2.必须是单例的(spring所创建该bean的实例个数只有一个)即bean中的scope配置成默认即可。
// 因为此close方法在接口 ApplicationContext 中没有定义,而在实现类中提供了该方法,我们可以使用反射,因为反射最后执行的就是实现类中的方法。
applicationContext.getClass().getMethod("close").invoke(applicationContext);
}
}
-
六、依赖注入Bean 的属性(xml)
- 注入依赖对象可以采用:
手工装配
或自动装配
。在实际应用中
建议使用手工装配
,因为自动装配会产生未知情况,开发人员无法预见最终的装配结果。- 手动装配:一般进行配置信息都采用手动装配。
- 基于xml装配基于注解装配 => 之后讲解
- 构造方法注入
- 属性setter方法注入
- 接口注入(spring不支持)
- 基于xml装配基于注解装配 => 之后讲解
- 自动装配:在struts 和spring 整合的时候使用自动装配。
- byType:按类型装配
- byName:按名称装配
- constructor:按构造装配
- autodetect:不确定装配(即自动装配)
- 手动装配:一般进行配置信息都采用手动装配。
构造方法
Bean对象类:
public class User { private Integer uid; private String username; private Integer age; public User(Integer uid, String username) { // 构造方法一 super(); this.uid = uid; this.username = username; } public User(String username, Integer age) { // 构造方法二 super(); this.username = username; this.age = age; } // 省略getter 和 setter 方法 // ......
在spring容器中进行配置:
applicationContext.xml
<bean id="userId" class="entity.User">
<constructor-arg index="0" type="java.lang.String" value="1">constructor-arg>
<constructor-arg index="1" type="java.lang.Integer" value="2">constructor-arg>
bean>
setter方法
在spring容器中进行配置:
applicationContext.xml
<bean id="personId" class="entity.Person">
<property name="pname" value="晓艺">property>
<property name="age">
<value>26value>
property>
<property name="homeAddr" ref="homeAddrId">property>
<property name="companyAddr">
<ref bean="companyAddrId">ref>
property>
bean>
<bean id="homeAddrId" class="entity.Address">
<property name="addr" value="山西运城">property>
<property name="tel" value="911">property>
bean>
<bean id=