对于一个基本的JDBC存取Q?span lang="EN-US">Connection的取得，Statement的徏立，异常处理Q?span lang="EN-US">Statement的关闭，Connection的关闭这些流E大致在不同的数据库技术上大致是相同的?span lang="EN-US">Spring提供?span lang="EN-US">JdbcTemplatec，被设计ؓU程安全Q当中所提供的一些操作方法封装了cM上面的流E?span lang="EN-US">
?span style="FONT: 7pt 'Times New Roman'">
对于UserDAO.java?span lang="EN-US">JdbcTemplate改进
只需要改q相应的Ҏ可以了Q其它的E序与文件不用变动?span lang="EN-US">
package com.kela.spring.jdbc;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import com.kela.spring.util.Util;
public class Test implements IUserDAO {
private JdbcTemplate jdbcTemplate;
public void setDataSource(DataSource dataSource) {
jdbcTemplate = new JdbcTemplate(dataSource);
}
public void insert(User user) {
String name = user.getName();
int age = user.getAge().intValue();
String sql = "INSERT INTO user (name, age) VALUES ('" + name + "', " + age + ")";
//
转码
sql = Util.GBKToISO(sql);
jdbcTemplate.update(sql);
}
public User find(Integer id) {
String sql = "SELECT * FROM user WHERE id = " + id.intValue();
List rs = jdbcTemplate.queryForList(sql);
Iterator it = rs.iterator();
if(it.hasNext()) {
Map userMap = (Map)it.next();
Integer i = new Integer(userMap.get("id").toString());
String name = Util.getStr(userMap.get("name").toString());//
转码
Integer age = new Integer(userMap.get("age").toString());
User user = new User();
user.setId(i);
user.setAge(age);
user.setName(name);
return user;
}
return null;
}
}
?span style="FONT: 7pt 'Times New Roman'">
几种JdbcTemplate执行与更斎ͼ查询的演C?span lang="EN-US">
AQ?span style="FONT: 7pt 'Times New Roman'">
使用JdbcTemplate?span lang="EN-US">executeQ）Ҏ执行SQL陈述?span lang="EN-US">
jdbcTemploat.execute(sql);
BQ?span style="FONT: 7pt 'Times New Roman'">
如果?span lang="EN-US">Update?span lang="EN-US">insertQ?span lang="EN-US">updateQ）Ҏ?span lang="EN-US">
???o:p>
使用预编?span lang="EN-US">SQLQ?span lang="EN-US">
public void insert(User user) {
final String name = user.getName();
final int age = user.getAge().intValue();
jdbcTemplate.update(new PreparedStatementCreator() {
public PreparedStatement createPreparedStatement(Connection conn) throws SQLException {
String sql = "INSERT INTO user (name, age) VALUES (?, ?)";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setString(1, name);
ps.setInt(2, age);
return ps;
}
}
);
}
???o:p>
public void insert(User user) {
final String name = user.getName();
final int age = user.getAge().intValue();
String sql = "INSERT INTO user (name, age) VALUES (?, ?)";
jdbcTemplate.update(sql, new PreparedStatementSetter() {
public void setValues(PreparedStatement ps) throws SQLException {
ps.setString(1, name);
ps.setInt(2, age);
}
});
}
???o:p>
public void insert(User user) {
String sql = "INSERT INTO user (name, age) VALUES (?, ?)";
jdbcTemplate.update(sql, new Object[] {user.getName(), user.getAge()});
}
???
CQ?span style="FONT: 7pt 'Times New Roman'">
使用JdbcTemplateq行查询Ӟ可是使用queryForXXXQ）{方法?span lang="EN-US">
//
q回一个整?span lang="EN-US">
jdbcTemplate.queryForInt(“select count
Q?span lang="EN-US">*Q?span lang="EN-US"> from user?span lang="EN-US">)Q?span lang="EN-US">
//
q回一个查询后的结果对?span lang="EN-US">
jdbcTemplate.queryForObject(“select name from user where id = ??
new Object[] {id},
java.lang.String.class);
//
q回多笔资料的列?span lang="EN-US">
jdbcTemplate.queryForList
Q?span lang="EN-US">select * from user?/span>Q?span lang="EN-US">;
List
中包括的?span lang="EN-US">Map对象Q每?span lang="EN-US">Map对象代表查询l果的一行记录?span lang="EN-US">
]]>
]]>
摘要Q?span lang="EN-US">Spring?span lang="EN-US">JDBC支持Q?span lang="EN-US">Spring提供?span lang="EN-US">DAO框架Q提供了Ҏ据库存取时异常的装Q提供的JdbcTemplatecd大简化了JDBC?span lang="EN-US">API上的操作{?span lang="EN-US">
一个传l?span lang="EN-US">DAO的例子?span lang="EN-US">
如，现在有一个数据库?span lang="EN-US">userQ该表有idQ?span lang="EN-US">nameQ?span lang="EN-US">age三个字段。对该表抽象得出User对象Q在q行数据库操作时Q?span lang="EN-US">findQ?span lang="EN-US">insertQ?span lang="EN-US">updateQ?span lang="EN-US">deleteQ应用程序不应依赖于一个实际的cd玎ͼ而是可以让它依赖一个接口，在应用程序中通过Ҏ口的声明来操作?span lang="EN-US">
?span style="FONT: 7pt 'Times New Roman'">
User.java
q是User对象
package com.kela.spring.jdbc;
public class User {
private Integer id;
private String name;
private Integer age;
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
?span style="FONT: 7pt 'Times New Roman'">
IUserDAO.java
q是IUserDAO接口Q负责声明对User对象的操作?span lang="EN-US">
package com.kela.spring.jdbc;
public interface IUserDAO {
public void insert(User user);
public User find(Integer id);
public void update(User user);
public void delete(User user);
}
?span style="FONT: 7pt 'Times New Roman'">
UserDAO.java
具体的数据库存取c，实现?span lang="EN-US">IUserDAO接口?span lang="EN-US">
package com.kela.spring.jdbc;
public class UserDAO implements IUserDAO {
public void insert(User user) {
Connnection conn = null;
Statement stmt = null;
try {
//
执行数据库插入操?span lang="EN-US">
} catch (SQLException e) {
//?o:p>
} finally{
//?o:p>
}
}
public User find(Integer id) {
//
查询
return user;
}
public void update(User user) {
//?o:p>
}
public void delete(User user) {
//?o:p>
}
}
?span style="FONT: 7pt 'Times New Roman'">
Test.java
在应用程序中q行数据存取Ӟ可以使用IUserDAO来声明接口，q行数据操作?span lang="EN-US">
??o:p>
User user = new User();
user.setId(new Integer(2));
user.setName(“kela?;
user.setAge(new Integer(28));
IUserDAO userDao = new UserDAO();
userDao.insert(user);
??o:p>
?span style="FONT: 7pt 'Times New Roman'">
学习结
׃依赖于接口，所以可以随时替?span lang="EN-US">IUserDAO的实现类Q在IUserDAO接口声明的操作方法上q没有Q何于底层数据库存取的技术细节，Spring?span lang="EN-US">DAO框架q是Zq样的原理，应用程序与底层存取技术隔d来?span lang="EN-US">
]]>
?span lang="EN-US">JDK1.3之后加入了可协助开发动态代理功能的APIQ你不必为特定对象与Ҏ~写特定的代理对象，使用动态代理，可以使用一个处理者（HandlerQ服务于各个对象?span lang="EN-US">
?span style="FONT: 7pt 'Times New Roman'">
LogHandler.java
package com.kela.spring.aop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import org.apache.log4j.Logger;
public class LogHandler implements InvocationHandler {
private Logger log = Logger.getLogger(this.getClass().getName());
private Object delegate;
public Object bind(Object delegate) {
this.delegate = delegate;
return Proxy.newProxyInstance(delegate.getClass().getClassLoader(), delegate.getClass().getInterfaces(), this);
}
public Object invoke(Object arg0, Method method, Object[] args)
throws Throwable {
Object result = null;
try {
log.info("hello
Ҏ开始执?span lang="EN-US">... ...");
result = method.invoke(delegate, args);
log.info("hello
Ҏ执行完毕");
} catch (Exception e) {
System.out.println("[ERROR]" + e.getMessage());
}
return result;
}
}
?span style="FONT: 7pt 'Times New Roman'">
IHell.java
package com.kela.spring.aop;
public interface IHello {
public void hello(String name);
}
?span style="FONT: 7pt 'Times New Roman'">
HelloSpeaker.java
package com.kela.spring.aop;
public class HelloSpeaker implements IHello {
public void hello(String name) {
System.out.println("
你好Q?span lang="EN-US">" + name);
}
}
?span style="FONT: 7pt 'Times New Roman'">
ProxyDemo.java
package com.kela.spring.aop;
public class ProxyDemo {
public void method_2() {
LogHandler logHandler = new LogHandler();
IHello helloProxy = (IHello)logHandler.bind(new HelloSpeaker());
helloProxy.hello("kela");
}
public static void main(String[] args) {
ProxyDemo proxyDemo = new ProxyDemo();
proxyDemo.method_2();
}
}
?span style="FONT: 7pt 'Times New Roman'">
学习结
使用代理对象记录等于业务逻辑无关的动作或d提取出来Q设计ؓ一个服务对象，?span lang="EN-US">LogHandler和上一节中的HelloProxyQ这L对象UC为切面（AspectQ?span lang="EN-US">
]]>
在一个服务的程中插入与业务逻辑无关的系l服务逻辑Q比?span lang="EN-US"> Logging?span lang="EN-US">SecurityQ，q样的逻辑UCؓCross-cutting concernsQ将Cross-cutting concerns独立出来设计Z个对象，q样的特D对象称之ؓAspectQ?span lang="EN-US">Aspect-oriented programming着重在Aspect的设计及与应用程序的l入Q?span lang="EN-US">WeaveQ?span lang="EN-US">
?span style="FONT: 7pt 'Times New Roman'">
静态代?span lang="EN-US">
在静态代理的实现中，代理对象与被代理对象都必d现同一个接口，在代理对象中可以实现日志记录{相x务，q在需要的时候再呼叫被代理的对象Q如此代理对象当中就可以仅保留业务相兌责?span lang="EN-US">
?span style="FONT: 7pt 'Times New Roman'">
IHello.java
package com.kela.spring.aop;
public interface IHello {
public void hello(String name);
}
?span style="FONT: 7pt 'Times New Roman'">
HelloSpeaker.java
package com.kela.spring.aop;
public class HelloSpeaker implements IHello {
public void hello(String name) {
System.out.println("
你好Q?span lang="EN-US">" + name);
}
}
?span style="FONT: 7pt 'Times New Roman'">
HelloProxy.java
package com.kela.spring.aop;
import org.apache.log4j.Logger;
public class HelloProxy implements IHello {
private Logger log = Logger.getLogger(this.getClass().getName());
private IHello helloObject;
public HelloProxy(IHello helloObject) {
this.helloObject = helloObject;
}
public void hello(String name) {
//
日志记录
log.info("hello
Ҏ开始执?span lang="EN-US">... ...");
//
执行业务逻辑
helloObject.hello(name);
//
日志记录
log.info("hello
Ҏ执行完毕");
}
}
?span style="FONT: 7pt 'Times New Roman'">
ProxyDemo.java
package com.kela.spring.aop;
public class ProxyDemo {
public static void main(String[] args) {
HelloProxy proxy = new HelloProxy(new HelloSpeaker());
proxy.hello("KELA");
}
}
?span style="FONT: 7pt 'Times New Roman'">
q行l果
HelloProxy - hello
Ҏ开始执?/span>
... ...
你好Q?/span>
KELA
HelloProxy - hello
Ҏ执行完毕
?span style="FONT: 7pt 'Times New Roman'">
学习结
静态代理中Q代理对象的一个接口只服务于一U类型的对象Q而且如果要代理的Ҏ很多Q势必要为每个方法进行代理，静态代理在E序规模E大时就无法胜Q?span lang="EN-US">
]]>
?span style="FONT: 7pt 'Times New Roman'">
Bean
的徏?span lang="EN-US">
?span lang="EN-US">BeanFactorydBean定义文gQƈ生成各个Bean实例?span lang="EN-US">
?span lang="EN-US">Spring中，默认取得的实例ؓSingleton模式Q即每一?span lang="EN-US">context.getBean(“beanName?取得的对象都是同一个，而不是每ơ都产生一个新的对象。大部分情况?span lang="EN-US">Singleton是能够满求的Q如果考虑到线E安全等的问题，需使用Prototype模式Q即每次取得的对象都是一个独立的对象Q只需要将singleton=”false?/span>卛_?span lang="EN-US">
如：
<bean
id=
"someBean"
class=
"com.kela.spring.ioc.SomeBean"
singleton=
"false"
>
?span style="FONT: 7pt 'Times New Roman'">
属性注?span lang="EN-US">
执行相关?span lang="EN-US">Bean属性依赖注?b style="mso-bidi-font-weight: normal">
?span style="FONT: 7pt 'Times New Roman'">
BeanNameAware
?span lang="EN-US">setBeanNameQ）
如果BeancL实现org.springframework.beans.factory.BeanNameAware接口Q则执行它的setBaenNameQ）Ҏ?span lang="EN-US">
实现BeanNameAware接口?span lang="EN-US">Beanc，在依赖关p设定完成后Q初始化Ҏ之前Q将Bean的定义文件中的名U设定给Bean?span lang="EN-US">
注：Spring中提供了一?span lang="EN-US">Aware相关接口Q实现这?span lang="EN-US">Aware接口?span lang="EN-US">Beancd被初始化之后Q可以取得一?span lang="EN-US">Spring所提供的资源或使用某些功能?span lang="EN-US">
一旦实C提供的相x口，则应用程序就会用到Spring的相?span lang="EN-US">APIQ而与Spring产生耦合关系?span lang="EN-US">
?span style="FONT: 7pt 'Times New Roman'">
BeanFactoryAware
?span lang="EN-US">setBeanFactoryQ）
如果beancL实现org.springframework.beans.factory.BeanFactoryAware接口Q则执行它的setBeanFactory?span lang="EN-US">
实现BeanFactoryAware接口?span lang="EN-US">Beanc，在依赖关p设定完成后Q初始化Ҏ之前Q?span lang="EN-US">Spring容器会注入BeanFactory的实例?span lang="EN-US">
?span style="FONT: 7pt 'Times New Roman'">
BeanPostProcessor
?span lang="EN-US">postProcessBeforeInitializationQ）
如果M?span lang="EN-US">org.springfaramwork.beans.factory.config.BeanPostProcessor实例?span lang="EN-US">Bean实例兌Q则执行BeanPostProcessors实例?span lang="EN-US">postProcessBeforeInitializationQ）Ҏ?span lang="EN-US">
?span style="FONT: 7pt 'Times New Roman'">
InitializingBean
?span lang="EN-US">afterPropertiesSetQ）
如果BeancM实现org.springfaramwork.beans.factory.InitializingBean接口Q则执行它的afterPropertiesSetQ）Ҏ?span lang="EN-US">
?span style="FONT: 7pt 'Times New Roman'">
Bean
定义文g中定?span lang="EN-US">init-method
可以?span lang="EN-US">Bean定义文g使用?span lang="EN-US">init-method”属性设定方法名Uͼ例如Q?span lang="EN-US">
<bean
id=
"someBean"
class=
"com.kela.spring.ioc.SomeBean"
init-method=
"initBean"
>
如果有以上设定的话，则进行至q个阶段Ӟ׃执行initBeanQ）Ҏ?span lang="EN-US">
?span style="FONT: 7pt 'Times New Roman'">
BeanPostProcessor
?span lang="EN-US">postProcessAfterInitializationQ）
如果M?span lang="EN-US">org.springfaramwork.beans.factory.config.BeanPostProcessor实例?span lang="EN-US">Bean实例兌Q则执行BeanPostProcessors实例?span lang="EN-US">postProcessAfterInitializationQ）Ҏ?span lang="EN-US">
?span style="FONT: 7pt 'Times New Roman'">
DisposableBean
?span lang="EN-US">destroyQ）
在容器关闭时Q如?span lang="EN-US">BeancL实现org.springframework.beans.factory.DisposableBean接口Q则执行它的destroyQ）Ҏ?span lang="EN-US">
?span style="FONT: 7pt 'Times New Roman'">
Bean
定义文g中定?span lang="EN-US">destroy-method
在容器关闭时Q可以在Bean定义文g中用?span lang="EN-US">destroy-method”属性设定方法名Uͼ例如Q?span lang="EN-US">
?o:p>
<bean
id=
"someBean"
class=
"com.kela.spring.ioc.SomeBean"
destroy-method=
"destroyBean"
>
如果有以上设定的话，则进行至q个阶段Ӟ׃执行destroyBeanQ）Ҏ?span lang="EN-US">
注意Q如果是使用ApplicationContext来生成ƈ理Bean的话则稍有不同，使用ApplicationContext来生成及理Bean实例的话Q在执行BeanFactoryAware?span lang="EN-US">setBeanFactoryQ）阶段之后Q若BeancM有实?span lang="EN-US">org.springframework.context.ApplicationContextAware接口Q则执行?span lang="EN-US">setApplicationContextQ）ҎQ接着才l进?span lang="EN-US">BeanPostProcessor?span lang="EN-US">postProcessBeforeInitializationQ）及之后的程?span lang="EN-US">
]]>
]]>
?span style="FONT: 7pt 'Times New Roman'">
StrudentBean.java
package com.kela.spring.ioc;
public class StudentBean {
private String name;
private AddressBean addressBean;
public AddressBean getAddressBean() {
return addressBean;
}
public void setAddressBean(AddressBean addressBean) {
this.addressBean = addressBean;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
?span style="FONT: 7pt 'Times New Roman'">
AddressBean.java
package com.kela.spring.ioc;
public class AddressBean {
private String addressName;
public String getAddressName() {
return addressName;
}
public void setAddressName(String addressName) {
this.addressName = addressName;
}
}
?span style="FONT: 7pt 'Times New Roman'">
beans-config_2.xml
<?xml
version=
"1.0"
encoding=
"GB2312"
?>
<!DOCTYPE
beans
PUBLIC
"-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd"
>
<beans>
<bean
id=
"addressBean"
class=
"com.kela.spring.ioc.AddressBean"
>
<property
name=
"addressName"
>
<value>
团结大街向阳?/span>
123
?/span>
</value>
</property>
</bean>
<bean
id=
"studentBean"
class=
"com.kela.spring.ioc.StudentBean"
>
<property
name=
"name"
>
<value>
KangFeng
</value>
</property>
<property
name=
"addressBean"
>
<!--
注意q里已不?/span>
value
了，改ؓ
ref
-->
<ref
bean=
"addressBean"
></ref>
</property>
</bean>
</beans>
?span style="FONT: 7pt 'Times New Roman'">
TestClass.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
public class TestClass {
public void method_2() {
try {
ApplicationContext context = new FileSystemXmlApplicationContext("bin\\com\\kela\\spring\\ioc\\beans-config_2.xml");
StudentBean studentBean = (StudentBean)context.getBean("studentBean");
System.out.println("
姓名Q?span lang="EN-US">" + studentBean.getName() + ";地址Q?span lang="EN-US">" + studentBean.getAddressBean().getAddressName());
} catch (Exception e) {
System.out.println("[ERROR]" + e.getMessage());
}
}
public static void main(String[] args) {
TestClass testClass = new TestClass();
testClass.method_2();
}
}
?span style="FONT: 7pt 'Times New Roman'">
学习结
?span lang="EN-US">Don’t Call MeQ?span lang="EN-US">I?span lang="EN-US">ll Call You”?span lang="EN-US">
]]>
?span style="FONT: 7pt 'Times New Roman'">
HelloBean.java
package com.kela.spring.ioc;
public class HelloBean {
private String name;
private String helloWord;
public HelloBean() {
}
public HelloBean(String name, String helloWord) {
this.name = name;
this.helloWord = helloWord;
}
public String getHelloWord() {
return helloWord;
}
public void setHelloWord(String helloWord) {
this.helloWord = helloWord;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
该程序文件中讲两U常用的注入方式写在了一赗?span lang="EN-US">
?span style="FONT: 7pt 'Times New Roman'">
Beans-config_1.xml
<?xml
version=
"1.0"
encoding=
"GB2312"
?>
<!DOCTYPE
beans
PUBLIC
"-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd"
>
<beans>
<!--
Type
3
Injection
通过构造方法（q里注意构造方法中参数的顺序保持一_
-->
<bean
id=
"helloBean_1"
class=
"com.kela.spring.ioc.HelloBean"
>
<constructor-arg
index=
"0"
>
<value>
KangFeng
</value>
</constructor-arg>
<constructor-arg
index=
"1"
>
<value>
你好Q?/span>
</value>
</constructor-arg>
</bean>
<!--
Type2
Injection
通过
set
注入?/span>
-->
<bean
id=
"helloBean_2"
class=
"com.kela.spring.ioc.HelloBean"
>
<property
name=
"name"
>
<value>
Kela
</value>
</property>
<property
name=
"helloWord"
>
<value>
hello
Q?/span>
</value>
</property>
</bean>
</beans>
?span style="FONT: 7pt 'Times New Roman'">
TestClass.java
package com.kela.spring.ioc;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
public class TestClass {
public void method_1() {
try {
ApplicationContext context = new
FileSystemXmlApplicationContext("bin\\com\\kela\\spring\\ioc\\beans-config_1.xml");
HelloBean helloBean_1 = (HelloBean)context.getBean("helloBean_1");
System.out.println("
构造方法注入（Ƣ迎词）Q?span lang="EN-US">" + helloBean_1.getName() + ";" + helloBean_1.getHelloWord());
HelloBean helloBean_2 = (HelloBean)context.getBean("helloBean_2");
System.out.println("set
Ҏ注入Q欢q词Q：" + helloBean_2.getName() + ";" + helloBean_2.getHelloWord());
} catch (Exception e) {
System.out.println("[ERROR]" + e.getMessage());
}
}
public static void main(String[] args) {
TestClass testClass = new TestClass();
testClass.method_1();
}
}
?span style="FONT: 7pt 'Times New Roman'"> 学习结
关于Constructor?span lang="EN-US">Setter注入的区别其实就是说Q是要在对象建时是就准备好资源还是在对象建立好之后，再?span lang="EN-US">SetterҎ来进行设定?span lang="EN-US">
从实际用角度来看，一个适用于较短的属性列Q一个适用于较长的属性列?b style="mso-bidi-font-weight: normal">
]]>
1.
准备工作
从下载的 spring 开发包 bin 目录下将相关 lib 加入至项目的 ClassPath 中?/span>
我加入的 lib 文g有：
spring.jar Q这个文件包括了所?/span> Spring 支持的功能所需要的c，而不再需要加入个别的 jar 文gQ关?/span> Spring 各个具体?/span> jar 包的使用范围Q可查询 Spring 的中文文）
commons-logging.jar Q?/span> log4j.jar Q?/span> log 日志所需Q?/span>
~写 log4j 配置文g log4j.properties Q将其放?/span> src 下， log4j.properties 内容如下Q?/span>
log4j.rootLogger=
ERROR,
stdout
log4j.appender.stdout=
org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=
org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=
%c
{1}
-
%m%n
我的工程目录l构如下Q?br />
SpringProjectQ工E名Uͼ
src
log4j.properties
lib
commons-logging.jar
log4j-1.2.9.jar
spring.jar
2.
~写W一?/span>
Spring
E序
q是一个简单的 JavaBean Q用来打声招呹{?/span>
?span style="FONT: 7pt 'Times New Roman'">
HelloBean.javapackage com.kela.spring.helloword;
public class HelloBean {
private String helloWord;
public String getHelloWord() {
return helloWord;
}
public void setHelloWord(String helloWord) {
this.helloWord = helloWord;
}
}
?span style="FONT: 7pt 'Times New Roman'">
beans-config.xml
<?xml
version=
"1.0"
encoding=
"GB2312"
?>
<!DOCTYPE
beans
PUBLIC
"-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd"
>
<beans>
<bean
id=
"helloBean"
class=
"com.kela.spring.helloword.HelloBean"
>
<property
name=
"helloWord"
>
<value>
你好Q?/span>
Spring
爱好者！
</value>
</property>
</bean>
</beans>
?span style="FONT: 7pt 'Times New Roman'">
TestClass.java
package com.kela.spring.helloword;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
public class TestClass {
public static void main(String[] args) {
try {
ApplicationContext context = new
FileSystemXmlApplicationContext("bin\\com\\kela\\spring\\helloword\\beans-config.xml");
HelloBean helloBean = (HelloBean)context.getBean("helloBean");
System.out.println(" 打印Ƣ迎词： " + helloBean.getHelloWord());
} catch (Exception e) {
System.out.println("[ERROR]" + e.getMessage());
}
}
}
3.
试
q行 TestClass.java 文gQ内容如下：
打印Ƣ迎词：你好Q?/span>
Spring
爱好者！
4. 学习结
通过配置的Ş式，?/span> HelloBean.java 文g中属?/span> helloWord 注入了一D|Ӟ你好Q?/span> spring 爱好者）Q?/span> HelloBean.java 文g中没有Q何与 Spring 有关的东西，在测试类中对 HelloBean 的声明是?/span> Spring 自动完成的?/span>
]]>