Spring使用之IOC配置篇

本计划分为四篇概括Spring常用的知识：IOC配置篇、AOP配置篇、IOC注解篇、AOP注解篇。

Spring核心分为IOC和AOP，这两点在我的工作中经常使用，DI又是IOC的核心实现，理论不多说，程序只有测试通过才能是真正的理解入门，其他一切空谈。

 

下面是接口：

package spring.config.iInterface;

public interface IUserDAO {
public void save();
public void delete();
}

 

下面是Action类：

package spring.config.service;

import spring.config.iInterface.IUserDAO;

public class UserAction {
private IUserDAO userDao;//接口类型

public String register(){
System.out.println("register()方法被调用...");
userDao.save();
userDao.delete();
return "success";
}

//setter方式注入,自动调用
public void setUserDao(IUserDAO userDao){
System.out.println("--setUserDao(UserDAO userDao)被调用...--");
this.userDao = userDao;
}

public IUserDAO getUserDao() {
return userDao;
}
}

 

 

package spring.config.service;

import spring.config.iInterface.IUserDAO;

public class UserAction1 {
private IUserDAO userDao;
//构造方法注入,自动调用
public UserAction1() {
System.out.println("---constructs----default--");
}

public UserAction1(IUserDAO userDao,int a){
System.out.println("---constructs--1--a:"+a);
this.userDao = userDao;
}

public UserAction1(IUserDAO userDao){
System.out.println("---constructs----2--");
this.userDao = userDao;
}

public String register(){
userDao.save();
userDao.delete();
return "success";
}
}

下面是bean类

package spring.config.bean;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class MessageBean {
private String username;
private String password;
private int size;
private List<String> citys;
private Set<String> friends;
private Map<Integer,String> books;
private Properties props;

public void show(){
System.out.println("用户名:"+username);
System.out.println("密码:"+password);
System.out.println("允许连接数:"+size);
System.out.println("-----城市列表-----");
for(String str:citys){
System.out.println(str);
}
System.out.println("-----朋友列表-----");
for(String str:friends){
System.out.println(str);
}
System.out.println("------图书列表------");
Set<Integer> keys = books.keySet();
for(Integer key:keys){
System.out.println(key+" "+books.get(key));
}
System.out.println("------系统参数信息-----");
Set<?> params = props.keySet();
for(Object obj:params ){
System.out.println(obj+" : "
+props.getProperty(obj.toString()));
}
}

public void setCitys(List<String> citys) {
this.citys = citys;
}

public void setBooks(Map<Integer, String> books) {
this.books = books;
}

public void setProps(Properties props) {
this.props = props;
}

public void setFriends(Set<String> friends) {
this.friends = friends;
}

public void setSize(int size) {
this.size = size;
}

public void setPassword(String password) {
this.password = password;
}

public void setUsername(String username) {
this.username = username;
}
}

 

下面是配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
<!--
主要演示：
1、两种注入方式
2、复杂对象的property赋值设置
<property name="" ref="" value="">
<bean></bean>
<props></props>
<list></list>
<map></map>
<set></set>
</property>
-->
<beans>
<bean id="userdao" class="spring.config.impl.HibernateUserDAO">
</bean>

<!-- setter方式注入 -->
<bean id="useraction" class="spring.config.service.UserAction">
<property name="userDao" ref="userdao"></property>
</bean>

<!-- 构造器方式注入*****注：调用不同构造器需要配置多个不同的-->
<bean id="useraction1" class="spring.config.service.UserAction1">
<constructor-arg index="0" ref="userdao"/><!-- 该构造器中第一次参数、类型、引用 -->
<constructor-arg index="1" value="100" type="int"/><!-- 该构造器中第二次参数、类型、引用 -->
</bean>

<!-- 各种复杂类型值注入的写法 -->
<bean id="messagebean"
class="spring.config.bean.MessageBean">
<!-- private Properties props -->
<property name="props">
<props>
<prop key="url">http://www.tom.com</prop>
<prop key="username">zhangsan</prop>
<prop key="password">123456789</prop>
</props>
</property>

<!-- private Map<Integer,String> books -->
<property name="books">
<map>
<entry key="10" value="CoreJava">
</entry>
<entry key="11" value="JavaWeb">
</entry>
<entry key="12" value="SSH2">
</entry>
</map>
</property>

<!-- private Set<String> friends -->
<property name="friends">
<set>
<value>张三</value>
<value>李四</value>
<value>王五</value>
</set>
</property>

<!-- private List<String> citys -->
<property name="citys">
<list>
<value>北京</value>
<value>上海</value>
<value>深圳</value>
</list>
</property>

<!-- private String username -->
<property name="username">
<value>root</value>
</property>
<!-- private String username -->
<property name="password">
<value>1234</value>
</property>
<!-- private int size -->
<property name="size">
<value>15</value>
</property>
</bean>
</beans>
<!--
1、BeanFactory与ApplicationContext区别：
前者在需要时才调用bean实例化对象，
而后者默认是在XML一加载就会创建好各bean的实例(
当然可以通过设置singleton bean的lazy-load属性为true，来改变ApplicationContext的默认行为;)

bean依赖通常可以接受如下元素指定值:
value、ref、bean、list、map、props

2、总结：实际应用中,某个实例的属性值可能是某个方法的返回值、类的field值、属性值,
这种非常规注入方式,Spring同样支持
3、创建bean通常有如下方法：
*调用构造器创建一个bean实例
*BeanFactory调用某个类的静态工厂方法创建bean<单例模式>
*BeanFactory调用实例工厂方法创建bean<工厂模式>
-->

 

 

接下来呢，就是最后的测试类了：

package spring.config.test.ioc;

import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;

import spring.config.bean.MessageBean;
import spring.config.service.UserAction;
import spring.config.service.UserAction1;
/***
* 两种注入方式测试：
* @author Administrator
*1、采用setter方式注入
*2、采用constructs方式注入
*优缺点：
*1、setter方式注入：对构造器类型比较单一的，当指定参数不会参数冲突的可以用它，因为该方式
*没有参数类型的定义，<property name="" ref="" value=""></property>
*2、针对上述缺陷，有另一种构造器注入可以指定参数的类型
*<constructor-arg index="0" ref="userdao" type="int" value=""/>
*<constructor-arg index="1" ref="userdao" type="int" value=""/>
*state:success
*/
public class TestAction {
@Test
public void test(){
String configs = "src/spring/config/applicationContext.xml";
Resource r = new FileSystemResource(configs);
BeanFactory bf = new XmlBeanFactory(r);//bean元素工厂，他可以生产出类的实例
UserAction userAction =
(UserAction)bf.getBean("useraction");
userAction.register();
}

//@Test
public void test1(){
String configs = "src/spring/config/applicationContext.xml";
Resource r = new FileSystemResource(configs);
BeanFactory bf = new XmlBeanFactory(r);//bean元素工厂，他可以生产出类的实例
UserAction1 userAction1 =
(UserAction1)bf.getBean("useraction1");
userAction1.register();
}

/***
* 主要演示：
1、两张注入方式
2、复杂对象的property赋值设置
<property name="" ref="" value="">
<bean></bean>
<props></props>
<list></list>
<map></map>
<set></set>
</property>
* @author huawei
*
*/
//@Test
public void test2(){
String configs = "src/spring/config/applicationContext.xml";
Resource rs = new FileSystemResource(configs);
BeanFactory bf = new XmlBeanFactory(rs);
MessageBean msgBean =
(MessageBean)bf.getBean("messagebean");
msgBean.show();
}
}

 

csdn的编辑器真不好用，jar包未提供，很简单的例子。