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();

}

}

/***

* 1)JoinPoint

java.lang.Object[] getArgs()：获取连接点方法运行时的入参列表；

Signature getSignature() ：获取连接点的方法签名对象；

java.lang.Object getTarget() ：获取连接点所在的目标对象；

java.lang.Object getThis() ：获取代理对象本身；

2)ProceedingJoinPoint

ProceedingJoinPoint继承JoinPoint子接口，它新增了两个用于执行连接点方法的方法：

java.lang.Object proceed() throws java.lang.Throwable：通过反射执行目标对象的连接点处的方法；

java.lang.Object proceed(java.lang.Object[] args) throws java.lang.Throwable：通过反射执行目标对象连接点处的方法，不过使用新的入参替换原来的入参。

*/

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