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