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包未提供，很简单的例子。