控制反轉——Spring通過一種稱作控制反轉（IoC）的技術促進了松耦合。當應用了IoC，一個對象依賴的其它對象會通過被動的方式傳遞進來，而不是這個對象自己創建或者查找依賴對象。你可以認爲IoC與JNDI相反——不是對象從容器中查找依賴，而是容器在對象初始化時不等對象請求就主動將依賴傳遞給它。
IOC
高層模塊不應該依賴低層模塊,而是模塊都必須依賴於抽象.
業務與抽象結合,不依賴於實現.
通用的Bean工廠，通過各種方式獲得Bean對象以及Bean對象的管理。
控制反轉：
把對象的創建交給spring容器來做
spring容器創建對象的方式
1、默認是調用默認的構造函數
2、利用靜態工廠方法創建
spring調用工廠方法產生對象，但是真正創建對象還是由程序員來完成的
3、實例工廠方法
說明：
spring配置文件中，只要是一個bean就會爲該bean創建對象
spring容器創建對象的時機
在單例的情況下
1、在默認的情況下，啓動spring容器創建對象
2、在spring的配置文件bean中有一個屬性lazy-init="default/true/false"
1、如果lazy-init爲"default/false"在啓動spring容器時創建對象
2、如果lazy-init爲"true",在context.getBean時纔要創建對象
意義：
在第一種情況下可以在啓動spring容器的時候，檢查spring容器配置文件的正確性，如果再結合tomcat,
如果spring容器不能正常啓動，整個tomcat就不能正常啓動。但是這樣的缺點是把一些bean過早的放在了
內存中，如果有數據，則對內存來是一個消耗
在第二種情況下，可以減少內存的消耗，但是不容易發現錯誤
在多例的情況下
就是一種情況：在context.getBean時才創建對象
spring的bean中的scope
1、由spring產生的bean默認是單例的
2、可以在spring的配置文件中，scope的值進行修改="singleton/prototype/request/session/global session"
3、如果spring的配置文件的scope爲"prototype"，則在得到該bean時才創建對象
spring容器對象的生命週期：
1、spring容器創建對象
2、執行init方法
3、調用自己的方法
4、當spring容器關閉的時候執行destroy方法
接口Dao.java
package bean;
public interface Dao {
public void save();
public void delete();
public void update();
}
實現接口中的所有方法
package bean;
public class UserDao implements Dao {
@Override
public void save() {
System.out.println("user Save");
}
@Override
public void delete() {
System.out.println("user delete");
}
@Override
public void update() {
System.out.println("user update");
}
}
package bean;
public class BoardDao implements Dao {
@Override
public void save() {
System.out.println("board Save");
}
@Override
public void delete() {
System.out.println("board delete");
}
@Override
public void update() {
System.out.println("board update");
}
}
靜態工廠和普通工廠
StaticFactory.java
package bean;
public class StaticFactory {
//靜態工廠
public static Dao getDao(String name){
//統一管理 如讀取資源，記錄日誌，事務管理
if(name.equals("user")){
return new UserDao();
}else{
return new BoardDao() ;
}
}
//普通工廠
public Dao getComDao(String name){
//統一管理
if(name.equals("user")){
return new UserDao();
}else{
return new BoardDao() ;
}
}
}
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
<!-- 靜態工廠 -->
<bean name="dao" class="bean.StaticFactory" factory-method="getDao">
<constructor-arg>
<value>user</value>
</constructor-arg>
</bean>
<!-- 普通工廠 -->
<!-- Dao dao=(Dao) ctx.getBean("userDao"); -->
<bean name="factory" class="bean.StaticFactory"></bean>
<bean name="userDao" factory-bean="factory" factory-method="getComDao">
<constructor-arg>
<value>board</value>
</constructor-arg>
</bean>
</beans> ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
Dao dao=StaticFactory.getDao("board");//通過靜態工廠
// Dao dao=(Dao) ctx.getBean("userDao");//通過普通工廠
dao.update();
Bean的生命週期
在UserDao中加上兩個方法
public void init(){
System.out.println("useDao被初始化");
}
public void destory(){
System.out.println("useDao被銷燬");
}在XML文件中配置生命週期（運行代碼時會進行初始化，而銷耗在沒有關閉時不會自動輸出）
<!-- 聲明週期 -->
<bean name="user1" class="bean.UserDao" init-method="init"
destroy-method="destory">
</bean> Topic.java
package util;
public class Topic {
private String id;
private String title;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
}
User.java聲明各種集合
package util;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
public class User {
private String id;
private String name;
private List list=new ArrayList();
private Set sets=new HashSet();
private Map maps=new HashMap();
private Properties pros=new Properties();
String[] strs;
Topic[] topics;//對象數組
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List getList() {
return list;
}
public void setList(List list) {
this.list = list;
}
public Set getSets() {
return sets;
}
public void setSets(Set sets) {
this.sets = sets;
}
public Map getMaps() {
return maps;
}
public void setMaps(Map maps) {
this.maps = maps;
}
public Properties getPros() {
return pros;
}
public void setPros(Properties pros) {
this.pros = pros;
}
public String[] getStrs() {
return strs;
}
public void setStrs(String[] strs) {
this.strs = strs;
}
public Topic[] getTopics() {
return topics;
}
public void setTopics(Topic[] topics) {
this.topics = topics;
}
}
XML文件配置
<!-- 裝配各種類型對象 -->
<bean name="topic1" class="util.Topic">
<property name="id">
<value>1</value>
</property>
<property name="title">
<value>java</value>
</property>
</bean>
<bean name="topic2" class="util.Topic">
<property name="id">
<value>2</value>
</property>
<property name="title">
<value>c#</value>
</property>
</bean>
<bean name="user" class="util.User">
<property name="id">
<value>1</value>
</property>
<property name="name">
<value>csdn</value>
</property>
<property name="list">
<list>
<ref bean="topic1" />
<ref bean="dao" />
<value>123</value>
<value>465</value>
<value></value>
<null></null>
</list>
</property>
<property name="sets">
<set>
<bean id="date" class="java.util.Date"></bean>
<ref bean="topic2" />
</set>
</property>
<property name="maps">
<map>
<entry>
<key>
<value>java</value>
</key>
<ref bean="topic1" />
</entry>
<entry>
<key>
<value>sql</value>
</key>
<value>oracle</value>
</entry>
</map>
</property>
<property name="pros">
<props>
<prop key="java">
hibernate
</prop>
<prop key="jsp">
struts
</prop>
</props>
</property>
<property name="strs">
<list>
<value>javax</value>
<value>jspx</value>
</list>
</property>
<property name="topics">
<array>
<ref bean="topic1" />
<ref bean="topic2" />
</array>
</property>
</bean>測試取出所有的類型
ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
Topic dao=(Topic) ctx.getBean("topic1");
System.out.println(dao.getId()+"--"+dao.getTitle());
//ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
Topic dao1=(Topic) ctx.getBean("topic2");
System.out.println(dao1.getId()+"--"+dao1.getTitle());
User user=(User) ctx.getBean("user");
System.out.println(user.getId()+"-user-"+user.getName());
for(int i=0;i<user.getList().size();i++){
System.out.println(user.getList().get(i));
}
Set us=user.getSets();
Iterator iterator=us.iterator();
while(iterator.hasNext()){
System.out.println("set集合"+iterator.next());
}
Map map=user.getMaps();
Set set=map.keySet();
Iterator iterator2=set.iterator();
while(iterator2.hasNext()){
String k=(String) iterator2.next();
System.out.println("map集合"+k);
System.out.println("map集合"+map.get(k));
}
System.out.println("pros:"+user.getPros());
//System.out.println(user.getStrs());
String s[]=user.getStrs();
for(String x:s){
System.out.println("strs:"+x);
}
Topic[] sx=user.getTopics();
for(Topic xx:sx){
System.out.println("topics:"+xx);
}