Java——Spring配置
Chinese.java
<?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"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"
default-autowire="byName" default-lazy-init="true">
<!-- default-autowire="byName" 根据属性名自动装配,default-lazy-init="true" spring配置默认default-lazy-init为false,当配置为true时sping不会再去加载整个对象实例图,大大减少了初始化的时间,减少了spring的启动速度。
这样做只是为了在开发过程中节约启动时间,在部署到实际环境中,倒是没必要设置default-lazy-init为true。毕竟部署到实际环境中不是经常的事,每次启动1分钟倒不是大问题,而且可以提高服务器效率 -->
<!-- 配置数据源 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost/ssh?characterEncoding=utf-8</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value>123</value>
</property>
</bean>
<!--配置SessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource" />
</property>
<property name="mappingResources">
<list>
<value>com/ssh/pojo/User.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>
<!-- hibernateTemplate -->
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>
<!-- 配置数据持久层 -->
<bean id="userDao" class="com.ssh.dao.impl.UserDaoImpl">
<property name="hibernateTemplate" ref="hibernateTemplate"></property>
</bean>
<!-- 配置业务逻辑层 -->
<bean id="userService" class="com.ssh.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>
<!-- 配置控制层 -->
<bean id="UserAction" class="com.ssh.action.UserAction" scope="prototype">
<property name="userService" ref="userService"></property>
</bean>
<!-- 配置pojo -->
<bean id="User" class="com.ssh.pojo.User" scope="prototype"/>
<!-- 事务管理 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>
</beans>
<?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"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"
default-autowire="byName" default-lazy-init="true">
<!-- default-autowire="byName" 根据属性名自动装配,default-lazy-init="true" spring配置默认default-lazy-init为false,当配置为true时sping不会再去加载整个对象实例图,大大减少了初始化的时间,减少了spring的启动速度。
这样做只是为了在开发过程中节约启动时间,在部署到实际环境中,倒是没必要设置default-lazy-init为true。毕竟部署到实际环境中不是经常的事,每次启动1分钟倒不是大问题,而且可以提高服务器效率 -->
<!-- 配置数据源 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost/ssh?characterEncoding=utf-8</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value>123</value>
</property>
</bean>
<!--配置SessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource" />
</property>
<property name="mappingResources">
<list>
<value>com/ssh/pojo/User.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>
<!-- hibernateTemplate -->
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>
<!-- 配置数据持久层 -->
<bean id="userDao" class="com.ssh.dao.impl.UserDaoImpl">
<property name="hibernateTemplate" ref="hibernateTemplate"></property>
</bean>
<!-- 配置业务逻辑层 -->
<bean id="userService" class="com.ssh.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>
<!-- 配置控制层 -->
<bean id="UserAction" class="com.ssh.action.UserAction" scope="prototype">
<property name="userService" ref="userService"></property>
</bean>
<!-- 配置pojo -->
<bean id="User" class="com.ssh.pojo.User" scope="prototype"/>
<!-- 事务管理 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>
</beans>
Java配置可以完全替代xml配置,也是Spring boot推荐的配置方式。
以下内容引用自:
package entity;import inter.Axe;import inter.Persion;public class Chinese implements Persion { private Axe axe; private String name; public void setAxe { this.axe = axe; } public void setName(String name) { this.name = name; } @Override public void useAxe() { // TODO Auto-generated method stub System.out.println("我是:"+name+axe.chop; } }
Java 配置通过@Configuration 和 @Bean 来完成。
基于Java的配置选项,可以使你在不用配置XML的情况下编写大多数的Spring配置。
AppConfig.java
-
@Configuration
声明当前类是一个配置类,相当于一个Spring配置的xml文件。 -
@Bean 注解在方法上,声明当前方法返回值是一个Java Bean。
@Configuration和@Bean注解
package inter;import org.springframework.beans.factory.annotation.Value;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import entity.Chinese;import entity.StoneAxe;@Configurationpublic class AppConfig { //相当于定义一个名为persionName的变量,其值为Jakee @Value String persionName; @Bean(name="chinese") public Persion persion() { Chinese p=new Chinese(); p.setAxe; p.setName(persionName); return p; } @Bean(name="chinese") public Axe stoneAxe() { return new StoneAxe(); }}
我们在实际开发中的原则:
带有@Configuration的注解类表示这个类可以使用Spring
IoC容器作为bean定义的来源。@Bean注解告诉Spring,一个带有@Bean的注解方法将返回一个对象,该对象应该被注册为在Spring应用程序上下文中的bean。最简单可行的@Configuration类如下所示:
- @Configuration:用于修饰一个Java配置类。
- Bean:用于修饰一个方法,该方法的返回值定义成容器中的一个Bean。
- 澳门威斯尼人最新网站,Value:用于修饰一个Field,用于为该Field配置一个值,相当于配置一个变量。
- Import:用于修饰一个Java配置类,用于向当前Java配置类中导入其他的Java配置类。
- Scope:用于修饰一个方法,指定该方法对应的Bean的生命域。
- Lazy:用于修饰一个方法,指定该方法对应的Bean是否需要延迟初始化。
- DespendsOn:用于修饰一个方法,指定在在初始化对应方法之前初始化指定的Bean。
-
全局配置使用Java配置(数据库配置,MVC相关配置);
-
业务配置使用注解配置(业务Bean的配置使用注解配置@Service,
@component,@Repository,@Controller)。
@Configuration
public class HelloWorldConfig {
@Bean
public HelloWorld helloWorld(){
return new HelloWorld();
}
}
1、如果以xml配置为主,需要在xml中加载Java配置类,代码如下:
对应XML配置如下:
<?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.xsd" > <context:annotation-config/> <!-- 加载Java配置类 --> <bean /></beans>
实例:
<beans>
<bean id="helloWorld" class="com.jsoft.testspring.testjavaconfiguration.HelloWorld" />
</beans>
2、如果以Java配置类为主,需要在Java配置类中加载xml配置,代码如下:
在这里,带有@Bean注解的方法名称作为bean的ID,它创建并返回实际的bean。你的配置类可以声明多个@Bean。一旦定义了配置类,你就可以使用AnnotationConfigApplicationContext来加载并把他们提供给Spring容器,如下所示:
@Configuration@ImportResource("classpath:/beans.xml")public class AppConfig(){ .............}
public static void main( String[] args )
{
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(HelloWorldConfig.class);
HelloWorld helloWorld = applicationContext.getBean(HelloWorld.class);
helloWorld.setMessage("Hello World!");
helloWorld.getMessage();
}
-
创建一个业务类
package com.cz.javaconfig;
/**
-
Created by Administrator on 2017/5/6.
*/
public class FunService {public String sayHello(){
return "hello world!";
}
}
-
当然,你可以加载各种配置类,如下所示:
public static void main(String[] args) {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.register(AppConfig.class, OtherConfig.class);
ctx.register(AdditionalConfig.class);
ctx.refresh();
MyService myService = ctx.getBean(MyService.class);
myService.doStuff();
}
2. 创建一个消费业务对象类
例子:
package com.cz.javaconfig;
/**
* Created by Administrator on 2017/5/6.
*/
public class UseUserService {
private FunService funService;
public void setFunService(FunService funService) {
this.funService = funService;
}
public String sayHelloworld(){
return funService.sayHello();
}
}
pom.xml:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.jsoft.testspring</groupId>
<artifactId>testjavaconfiguration</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>testjavaconfiguration</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<!-- Spring Core -->
<!-- http://mvnrepository.com/artifact/org.springframework/spring-core -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.1.4.RELEASE</version>
</dependency>
<!-- Spring Context -->
<!-- http://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.1.4.RELEASE</version>
</dependency>
</dependencies>
</project>
-
主角登场,创建一个JAVA配置类
package com.cz.javaconfig;
import org.apache.catalina.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;import javax.jws.soap.SOAPBinding;
/**
- Java 配置类,代替xml配置文件
-
Created by Administrator on 2017/5/6.
*/
@Configuration
public class JavaConfig {@Bean
public FunService funService(){return new FunService();
}
@Bean
public UseUserService useUserService(){UseUserService useUserService = new UseUserService(); useUserService.setFunService(this.funService()); return useUserService;
}
@Bean
public UseUserService useUserService(FunService funService){UseUserService useUserService = new UseUserService(); useUserService.setFunService(funService); return useUserService;
}
}
HelloWorld.java:
package com.jsoft.testspring.testjavaconfiguration;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println(this.message);
}
}
-
运行测试
package com.cz.javaconfig;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import javax.jws.soap.SOAPBinding;
/**
-
Created by Administrator on 2017/5/6.
*/
public class TestJavaConfig {public static void main(String[] args) {
// 启动Spring上下文,并初始化配置文件 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(JavaConfig.class); UseUserService useUserService = context.getBean(UseUserService.class); System.out.printf(useUserService.sayHelloworld());
}
}
-
HelloWorldConfig.java:
package com.jsoft.testspring.testjavaconfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class HelloWorldConfig {
@Bean
public HelloWorld helloWorld(){
return new HelloWorld();
}
}
App.java:
package com.jsoft.testspring.testjavaconfiguration;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
/**
* Hello world!
*
*/
public class App
{
public static void main( String[] args )
{
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(HelloWorldConfig.class);
HelloWorld helloWorld = applicationContext.getBean(HelloWorld.class);
helloWorld.setMessage("Hello World!");
helloWorld.getMessage();
}
}
测试结果:
测试工程:
Bean的依赖性注入**
当Beans依赖对方时,表达这种依赖性非常简单,只要有一个bean方法调用另一个,如下所示:
@Configuration
public class HelloWorldConfig {
@Bean
public HelloWorld helloWorld(){
return new HelloWorld(message());
}
@Bean
public String message(){
return new String("Hello World");
}
}
可以看出,有依赖性时直接在类中调用新建的方法即可。
例子:
pom.xml:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.jsoft.testspring</groupId>
<artifactId>testjavaconfiguration</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>testjavaconfiguration</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<!-- Spring Core -->
<!-- http://mvnrepository.com/artifact/org.springframework/spring-core -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.1.4.RELEASE</version>
</dependency>
<!-- Spring Context -->
<!-- http://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.1.4.RELEASE</version>
</dependency>
</dependencies>
</project>
HelloWorld.java:
package com.jsoft.testspring.testjavaconfiguration;
public class HelloWorld {
private String message;
public HelloWorld(String message){
this.message = message;
}
public void getMessage(){
System.out.println(this.message);
}
}
HelloWorldConfig.java:
package com.jsoft.testspring.testjavaconfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class HelloWorldConfig {
@Bean
public HelloWorld helloWorld(){
return new HelloWorld(message());
}
@Bean
public String message(){
return new String("Hello World");
}
}
App.java:
package com.jsoft.testspring.testjavaconfiguration;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
/**
* Hello world!
*
*/
public class App
{
public static void main( String[] args )
{
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(HelloWorldConfig.class);
HelloWorld helloWorld = applicationContext.getBean(HelloWorld.class);
helloWorld.getMessage();
}
}
测试结果:
测试工程:
@Import注释
@import注解允许从另一个配置类中加载Bean定义。如下所示:
@Configuration
public class ConfigA {
@Bean
public A a() {
return new A();
}
}
@Configuration
@Import(ConfigA.class)
public class ConfigB {
@Bean
public B b() {
return new B();
}
}
现在,当实例化上下文时,不需要同时指定ConfigA.class和ConfigB.class,只要ConfigB类需要提供,如下所示:
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(ConfigB.class);
A a = ctx.getBean(A.class);
B b = ctx.getBean(B.class);
}
例子:
pom.xml:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.jsoft.testspring</groupId>
<artifactId>testjavaconfiguration</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>testjavaconfiguration</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<!-- Spring Core -->
<!-- http://mvnrepository.com/artifact/org.springframework/spring-core -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.1.4.RELEASE</version>
</dependency>
<!-- Spring Context -->
<!-- http://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.1.4.RELEASE</version>
</dependency>
</dependencies>
</project>
HelloWorld.java:
package com.jsoft.testspring.testjavaconfiguration;
public class HelloWorld {
private String message;
public HelloWorld(String message){
this.message = message;
}
public void getMessage(){
System.out.println(this.message);
}
}
HelloWorldConfig.java:
package com.jsoft.testspring.testjavaconfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class HelloWorldConfig {
@Bean
public HelloWorld helloWorld(){
return new HelloWorld(message());
}
@Bean
public String message(){
return new String("Hello World");
}
}
HelloWorldConfigB.java:
package com.jsoft.testspring.testjavaconfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
@Configuration
@Import(HelloWorldConfig.class)
public class HelloWorldConfigB {
@Bean
public String messageB(){
return new String("Hello B");
}
}
App.java:
package com.jsoft.testspring.testjavaconfiguration;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
/**
* Hello world!
*
*/
public class App
{
public static void main( String[] args )
{
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(HelloWorldConfigB.class);
HelloWorld helloWorld = applicationContext.getBean(HelloWorld.class);
helloWorld.getMessage();
}
}
可以看出不用再次引用HelloWorldConfig.java类了。
测试结果:
测试工程:
生命周期回调
@Bean注解支持指定任意的初始化和销毁回调方法,这与Spring元素中的Spring
XML的init-method和destroy-method属性非常相似。如下所示:
public class Foo {
public void init() {
}
public void cleanup() {
}
}
@Configuration
public class AppConfig {
@Bean(initMethod = "init", destroyMethod = "cleanup" )
public Foo foo() {
return new Foo();
}
}
例子:
pom.xml:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.jsoft.testspring</groupId>
<artifactId>testjavaconfiguration</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>testjavaconfiguration</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<!-- Spring Core -->
<!-- http://mvnrepository.com/artifact/org.springframework/spring-core -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.1.4.RELEASE</version>
</dependency>
<!-- Spring Context -->
<!-- http://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.1.4.RELEASE</version>
</dependency>
</dependencies>
</project>
HelloWorld.java:
package com.jsoft.testspring.testjavaconfiguration;
public class HelloWorld {
private String message;
public HelloWorld(String message){
this.message = message;
}
public void getMessage(){
System.out.println(this.message);
}
public void init(){
System.out.println("HelloWorld init");
}
public void cleanup(){
System.out.println("HelloWorld cleanup");
}
}
HelloWorldConfig.java:
package com.jsoft.testspring.testjavaconfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class HelloWorldConfig {
@Bean(initMethod="init",destroyMethod="cleanup")
public HelloWorld helloWorld(){
return new HelloWorld(message());
}
@Bean
public String message(){
return new String("Hello World");
}
}
App.java:
package com.jsoft.testspring.testjavaconfiguration;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
/**
* Hello world!
*
*/
public class App
{
public static void main( String[] args )
{
AbstractApplicationContext applicationContext = new AnnotationConfigApplicationContext(HelloWorldConfig.class);
HelloWorld helloWorld = applicationContext.getBean(HelloWorld.class);
helloWorld.getMessage();
applicationContext.registerShutdownHook();
}
}
测试结果:
测试工程:
指定Bean的作用域范围
默认范围是单实例,但是你可以重写带有@Scope注解的方法,如下所示:
@Configuration
public class AppConfig {
@Bean
@Scope("prototype")
public Foo foo() {
return new Foo();
}
}
例子:
pom.xml:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.jsoft.testspring</groupId>
<artifactId>testjavaconfiguration</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>testjavaconfiguration</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<!-- Spring Core -->
<!-- http://mvnrepository.com/artifact/org.springframework/spring-core -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.1.4.RELEASE</version>
</dependency>
<!-- Spring Context -->
<!-- http://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.1.4.RELEASE</version>
</dependency>
</dependencies>
</project>
HelloWorld.java:
package com.jsoft.testspring.testjavaconfiguration;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println(this.message);
}
}
HelloWorldConfig.java:
package com.jsoft.testspring.testjavaconfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
@Configuration
public class HelloWorldConfig {
@Bean
@Scope("prototype")
public HelloWorld helloWorld(){
return new HelloWorld();
}
}
@Scope的值和xml中配置的保持一致。
App.java:
package com.jsoft.testspring.testjavaconfiguration;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
/**
* Hello world!
*
*/
public class App
{
public static void main( String[] args )
{
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(HelloWorldConfig.class);
HelloWorld helloWorld = applicationContext.getBean(HelloWorld.class);
helloWorld.setMessage("Hello World 1!");
helloWorld.getMessage();
HelloWorld helloWorld2 = applicationContext.getBean(HelloWorld.class);
helloWorld2.getMessage();
}
}
测试结果:
测试工程:
更多Java配置的官方例子参考: