码迷，mamicode.com
首页 > 编程语言 > 详细

不错的Spring学习笔记(转)

时间：2014-12-08 22:56:28      阅读：464      评论：0      收藏：0      [点我收藏+]

标签：des   blog   http   io   ar   color   os   使用   sp   

Spring学习笔记（1）----简单的实例
---------------------------------
  
首先需要准备Spring包，可从官方网站上下载。
  
下载解压后，必须的两个包是spring.jar和commons-logging.jar。此外为了便于测试加入了JUnit包。
  
在Myeclipse中创建Java项目。
  
编写一个接口类，为了简单，只加入了一个方法。
  
Java代码  
1.package com.szy.spring.interfacebean;  
2.  
3.public interface PersonBean  
4.{  
5.    void show();  
6.}  
   
 然后写一个类实现这个接口。
   
  
  
Java代码  
1.package com.szy.spring.implbean;  
2.import com.szy.spring.interfacebean.PersonBean;  
3.  
4.public class UserBean implements PersonBean  
5.{  
6.  
7.    public void show()  
8.    {  
9.        System.out.println("Hello Kuka");  
10.    }  
11.  
12.}  
   
   
   
   
   
以上的过程我们再熟悉不过了，下面开始加入Spring的内容了。首先从下载的Sping包中找到配置文件，删除不需要的，找到最原始的部分：
   
  
  
Xml代码  
1.<?xml version="1.0" encoding="UTF-8"?>  
2.<beans xmlns="http://www.springframework.org/schema/beans"  
3.    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.    xmlns:context="http://www.springframework.org/schema/context"  
5.    xmlns:tx="http://www.springframework.org/schema/tx"  
6.    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
7.                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd  
8.                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
9.  
10.</beans>  
   
   
   
我们在配置文件中加入我们的bean信息
   
  
  
Xml代码  
1.<bean id="userBean" class="com.szy.spring.implbean.UserBean" />  
   
 其中id作为标识符，class为类的包路径。
   
这样我们的配置文件就写好了，完整的配置文件呢如下。
   
  
  
Xml代码  
1.<?xml version="1.0" encoding="UTF-8"?>  
2.<beans xmlns="http://www.springframework.org/schema/beans"  
3.    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.    xmlns:context="http://www.springframework.org/schema/context"  
5.    xmlns:tx="http://www.springframework.org/schema/tx"  
6.    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
7.                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd  
8.                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
9.  
10.    <bean id="userBean" class="com.szy.spring.implbean.UserBean" />  
11.</beans>  
   
   
   
   
   
最后我们创建一个测试类测试：
   
  
  
Java代码  
1.package com.szy.spring.test;  
2.  
3.import org.junit.Test;  
4.import org.springframework.context.ApplicationContext;  
5.import org.springframework.context.support.ClassPathXmlApplicationContext;  
6.import com.szy.spring.interfacebean.PersonBean;  
7.  
8.  
9.public class TestClass  
10.{  
11.    @Test  
12.    public void testMethod() throws Exception  
13.    {  
14.        //读取配置文件  
15.        ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");  
16.        //获取UserBean的实例  
17.        PersonBean bean=(PersonBean)ctx.getBean("userBean");  
18.        //调用方法  
19.        bean.show();  
20.    }  
21.}  
  
运行，输入如下结果：
   
  
结果代码  
1.Hello Kuka  
  
Ok，我们的第一个Spring程序成功运行。
  
  
  
Sping学习笔记（2）----实例化Bean的三种方式
-------------------------------------------
Spring的实例化Bean有三种方式：
   
 使用类构造器直接实例化
   
 使用静态工厂的方法实例化
   
 使用实例工厂方法实例化
   
   
   
三种方式对应的配置如下
   
  
  
Xml代码  
1.<?xml version="1.0" encoding="UTF-8"?>  
2.<beans xmlns="http://www.springframework.org/schema/beans"  
3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.        xmlns:context="http://www.springframework.org/schema/context"  
5.        xmlns:tx="http://www.springframework.org/schema/tx"  
6.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
7.                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd  
8.                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
9.        <!-- 使用类构造器直接实例化 -->    
10.        <bean id="userBean1" class="com.szy.spring.implbean.UserBean" />  
11.        <!-- 使用静态工厂的方法实例化 -->  
12.        <bean id="userBean2" class="com.szy.spring.factory.BeanFactory" factory-method="UserBeanService" />  
13.        <!-- 使用实例工厂方法实例化 -->  
14.        <bean id="factory" class="com.szy.spring.factory.BeanFactory" />  
15.        <bean id="userBean3" factory-bean="factory" factory-method="getUserBeanService" />  
16.</beans>  
   
   
   
   
   
其中BeanFactory类的代码如下
   
  
  
Java代码  
1.package com.szy.spring.factory;  
2.  
3.import com.szy.spring.implbean.UserBean;  
4.import com.szy.spring.interfacebean.PersonBean;  
5.  
6.public class BeanFactory  
7.{  
8.    //使用静态工厂的方法实例化使用  
9.    public static PersonBean UserBeanService()  
10.    {  
11.        return new UserBean();  
12.    }  
13.      
14.    public PersonBean getUserBeanService()  
15.    {  
16.        return new UserBean();  
17.    }  
18.}  
   
   
   
在这三种方式中我们最常用的还是第一种。
  
  
  
  
  
  
  
Spring学习笔记（3）----编码剖析Spring管理Bean的原理
--------------------------------------------------
  
  
Xml代码  
1.<?xml version="1.0" encoding="UTF-8"?>  
2.<beans xmlns="http://www.springframework.org/schema/beans"  
3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.        xmlns:context="http://www.springframework.org/schema/context"  
5.        xmlns:tx="http://www.springframework.org/schema/tx"  
6.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
7.                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd  
8.                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
9.        <bean id="userBean" class="com.szy.spring.implbean.UserBean" />  
10.</beans>  
   
   
   
Spring的配置文件中记录了类的包路径，因此我们首先是要读入配置文件。在配置文件中Bean有id和class两个属性，我们首先定义一个Bean类，包含这两个属性：
   
   
   
  
  
Java代码  
1.package com.szy.spring.implbean;  
2.  
3.public class Bean  
4.{  
5.    private String id;  
6.    private String className;  
7.    public String getId()  
8.    {  
9.        return id;  
10.    }  
11.    public void setId(String id)  
12.    {  
13.        this.id = id;  
14.    }  
15.    public String getClassName()  
16.    {  
17.        return className;  
18.    }  
19.    public void setClassName(String className)  
20.    {  
21.        this.className = className;  
22.    }  
23.      
24.}  
25.   
   
由于配置文件是xml文件，在这里使用Jdom包操作xml文件，读入配置文件中的Bean信息。
   
  
  
Java代码  
1./** 
2.     * 读取xml配置文件 
3.     * @param fileName 配置文件名 
4.     */  
5.    private void readXML(String fileName)  
6.    {  
7.        // 寻找配置文件  
8.        URL xmlPath = this.getClass().getClassLoader().getResource(fileName);  
9.        Document doc = null;  
10.        Element root = null;  
11.        try  
12.        {  
13.            SAXBuilder sb = new SAXBuilder(false);  
14.            doc = sb.build(new FileInputStream(new File(xmlPath.toURI())));  
15.            // 设置命名空间  
16.            Namespace xhtml = Namespace.getNamespace("xhtml",  
17.                    "http://www.springframework.org/schema/beans");  
18.            root = doc.getRootElement(); // 获取根元素  
19.            List<Element> list = root.getChildren("bean", xhtml); //获取全部bean节点  
20.            for (Element element : list)// 遍历节点，取得每个节点的属性  
21.            {  
22.                String id = element.getAttributeValue("id");  
23.                String className = element.getAttributeValue("class");  
24.                Bean bean = new Bean();  
25.                bean.setId(id);  
26.                bean.setClassName(className);  
27.                beanList.add(bean);  
28.            }  
29.        } catch (Exception e)  
30.        {  
31.            e.printStackTrace();  
32.        }  
33.  
34.    }  
   
   
   
 其中beanList是一个List对象，因为在配置文件中存在很多Bean。
   
   
   
得到了所有的Bean对象后，下面就实例化每个Bean对象，结果存放在Map对象中。
   
   
   
  
  
Java代码  
1./** 
2.     * bean的实例化 
3.     */  
4.    private void instanceBeans()  
5.    {  
6.        for (Bean bean : beanList)  
7.        {  
8.            try  
9.            {  
10.                if (bean.getClassName() != null && !"".equals(bean.getClassName().trim()))  
11.                    beanObject.put(bean.getId(), Class.forName(bean.getClassName()).newInstance());  
12.            } catch (Exception e)  
13.            {  
14.                e.printStackTrace();  
15.            }  
16.        }  
17.  
18.    }  
   
 其中beanObject为Map对象。
   
   
   
最后再加入一个方法，方便外部能获取Map中的对象
   
  
  
Java代码  
1./** 
2.     * 获取bean实例 
3.     * @param beanName 配置文件中bean的Id 
4.     * @return 
5.     */  
6.    public Object getBean(String beanName)  
7.    {  
8.        return this.beanObject.get(beanName);  
9.    }  
   
 完整的MyClassPathXMLApplicationContext见附件中的代码。
   
   
   
下面测试MyClassPathXMLApplicationContext类。
   
  
  
Java代码  
1.@Test  
2.    public void testMethod() throws Exception  
3.    {  
4.        //读取配置文件  
5.        MyClassPathXMLApplicationContext ctx=new MyClassPathXMLApplicationContext("applicationContext.xml");  
6.        //获取UserBean的实例  
7.        PersonBean bean=(PersonBean)ctx.getBean("userBean");  
8.        //调用方法  
9.        bean.show();  
10.    }  
   
   
   
输出结果
   
  
  
结果代码  
1.Hello Kuka  
   
   
   
成功。
   
上面仅是简单的演示了Spring管理Bean的原理，但是在实际操作中还需要考虑很对其它因素。
  
  
  
  
  
  
  
  
Spring学习笔记（4）----Bean节点信息配置
---------------------------------------
默认情况下，Spring的Ioc容器启动时会初始化bean，但是我们可以指定Bean节点的lazy-init="true"，来延迟初始化bean。这时候，只有第一次获取bean才会初始化bean。如
   
  
  
Xml代码  
1.<bean id="userBean" class="com.szy.spring.implbean.UserBean" lazy-init="true" />  
   
 如果想对所有的bean有应用延迟初始化，可以在跟节点beans设置default-lazy-init="true"，如下：
   
  
  
Xml代码  
1.<beans default-lazy-init="true"....>  
   
 此外，如果我们还想UserBean在实例化是调用初始化方法时，我们可以加入“init-method="init"”属性，其中init为Userbean中的init()方法，与之对应，“destroy-method="destroy"”为销毁属性。
   
在Spring中我们通过getBean(name)方法获得实例，那么我们每次获取的实例化对象是一个还是多个呢？
   
我们可以通过“==”进行测试
   
  
  
Java代码  
1.ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");     
2.PersonBean bean1=(PersonBean)ctx.getBean("userBean");  
3.PersonBean bean2=(PersonBean)ctx.getBean("userBean");  
4.System.out.println(bean1==bean2);  
   
 运行输出结果为：true
   
这说明了Bean交给sping容器管理之后，Bean默认情况下是单实例的。
   
如果我们想每次通过getBean(name)方法获得实例是一个新的实例化对象该怎么办呢？
   
在配置文件中节点bean有一个属性scope，只要我们配置如下即可：
   
  
  
Xml代码  
1.<bean id="userBean" class="com.szy.spring.implbean.UserBean" scope="prototype" />  
   
 在运行测试代码，输出结果为：false
  
  
  
Spring学习笔记（5）----依赖注入的简单实现
-----------------------------------------
Spring的核心机制是依赖注入。依赖注入让bean与bean之间以配置文件组织在一起，而不是以硬编码的方式耦合在一起。依赖注入(Dependency Injection)和控制反转(Inversion of Control)是同一个概念。具体含义是:当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，在传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在Spring里，创建被调用者的工作不再由调用者来完成，因此称为控制反转;创建被调用者实例的工作通常由Spring容器来完成，然后注入调用者，因此也称为依赖注入。管是依赖注入，还是控制反转，都说明Spring采用动态、灵活的方式来管理各种对象。对象与对象之间的具体实现互相透明。
   
下面通过简单的实例演示依赖注入。
   
项目中主要包含一下一个文件：
  
   
   
UserDAO是一个接口，包含了一个方法：
   
  
  
Java代码  
1.package com.szy.spring.dao;  
2.  
3.public interface UserDAO  
4.{  
5.    void show();  
6.}  
   
   
   
而UserDAO4MySqlImpl和UserDAO4OracleImpl实现了UserDAO中的方法。
   
  
  
Java代码  
1.package com.szy.spring.dao;  
2.public class UserDAO4MySqlImpl implements UserDAO  
3.{  
4.    public void show()  
5.    {  
6.        System.out.println("MySqlDAO Implement");  
7.    }  
8.}  
   
   
   
  
  
Java代码  
1.package com.szy.spring.dao;  
2.public class UserDAO4OracleImpl implements UserDAO  
3.{  
4.    public void show()  
5.    {  
6.        System.out.println("OracleDAO Implement");  
7.    }  
8.}  
   
   
   
UserService是另外一个包中的接口，
   
  
  
Java代码  
1.package com.szy.spring.service;  
2.  
3.public interface UserService  
4.{  
5.    void show();  
6.}  
   
   
   
UserServiceImpl实现了这个接口，
   
  
  
Java代码  
1.package com.szy.spring.service;  
2.  
3.import com.szy.spring.dao.UserDAO;  
4.  
5.public class UserServiceImpl implements UserService  
6.{  
7.    private UserDAO userDAO;  
8.      
9.    public void show()  
10.    {  
11.        userDAO.show();  
12.    }  
13.  
14.    public UserDAO getUserDAO()  
15.    {  
16.        return userDAO;  
17.    }  
18.    public void setUserDAO(UserDAO userDAO)  
19.    {  
20.        this.userDAO = userDAO;  
21.    }  
22.}  
   
 但是在实现这个接口中，调用了UserDAO中的方法。一般情况下我们需要在这里实例化一个UserDAO对象，比如
   
  
  
Java代码  
1.UserDAO userDAO=new UserDAO4MySqlImpl();  
   
 这样的话耦合度就比较高，通过spring我们可以降低耦合度。
   
在Sping的配置文件中，我们需要这样配置
   
  
  
Java代码  
1.<?xml version="1.0" encoding="UTF-8"?>  
2.<beans xmlns="http://www.springframework.org/schema/beans"  
3.    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.    xmlns:context="http://www.springframework.org/schema/context"  
5.    xmlns:tx="http://www.springframework.org/schema/tx"  
6.    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
7.                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd  
8.                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
9.    <bean id="mySqlDAO" class="com.szy.spring.dao.UserDAO4MySqlImpl"/>  
10.    <bean id="oracleDAO" class="com.szy.spring.dao.UserDAO4OracleImpl"/>  
11.    <bean id="userService" class="com.szy.spring.service.UserServiceImpl">  
12.        <!--构造方法注入    
13.            <property name="userDAO" ref="mySqlDAO"></property>  
14.        -->  
15.        <property name="userDAO" ref="oracleDAO"></property>  
16.    </bean>  
17.</beans>  
   
   
   
下面我们测试
   
  
  
Java代码  
1.ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");     
2.        UserService service=(UserService)ctx.getBean("userService");  
3.        service.show();  
   
   
   
输入内容为
   
  
  
输出代码  
1.OracleDAO Implement  
   
 如果我们想实用Mysql数据库呢？ 
   
此时我们只要修改配置文件即可，而不需要修改Java文件。
   
  
  
Xml代码  
1.<property name="userDAO" ref="mySqlDAO"></property>  
  
  
  
  
  
  
  
  
Spring学习笔记（6）----编码剖析Spring依赖注入的原理
---------------------------------------------------
在Spring学习笔记（3）中剖析了Spring管理Bean的原理，下面解释下Spring依赖注入的原理
   
在进行依赖注入时，我们的配置文件如下配置：
   
  
  
Xml代码  
1.<?xml version="1.0" encoding="UTF-8"?>  
2.<beans xmlns="http://www.springframework.org/schema/beans"  
3.    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.    xmlns:context="http://www.springframework.org/schema/context"  
5.    xmlns:tx="http://www.springframework.org/schema/tx"  
6.    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
7.                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd  
8.                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
9.    <bean id="mySqlDAO" class="com.szy.spring.dao.UserDAO4MySqlImpl"/>  
10.    <bean id="oracleDAO" class="com.szy.spring.dao.UserDAO4OracleImpl"/>  
11.    <bean id="userService" class="com.szy.spring.service.UserServiceImpl">  
12.        <!--构造方法注入    
13.            <property name="userDAO" ref="mySqlDAO"></property>  
14.        -->  
15.        <property name="userDAO" ref="oracleDAO"></property>  
16.    </bean>  
17.</beans>  
   
 根据配置文件信息，我们首先需要建立一个Bean类，用来保存bean节点的信息：
   
  
  
Java代码  
1.package com.szy.spring.bean;  
2.  
3.import java.util.List;  
4.  
5.public class Bean  
6.{  
7.    private String id;     
8.    private String className;   
9.    private List<Property> propertyList;  
10.    public Bean(String id, String className, List<Property> propertyList)  
11.    {  
12.        super();  
13.        this.id = id;  
14.        this.className = className;  
15.        this.propertyList = propertyList;  
16.    }  
17.    public String getId()     
18.    {     
19.        return id;     
20.    }     
21.    public void setId(String id)     
22.    {     
23.        this.id = id;     
24.    }     
25.    public String getClassName()     
26.    {     
27.        return className;     
28.    }     
29.    public void setClassName(String className)     
30.    {     
31.        this.className = className;     
32.    }  
33.    public List<Property> getPropertyList()  
34.    {  
35.        return propertyList;  
36.    }  
37.    public void setPropertyList(List<Property> propertyList)  
38.    {  
39.        this.propertyList = propertyList;  
40.    }     
41.}  
   
 此外，由于bean下存在property信息，因此我们还需要建立property类
   
  
  
Java代码  
1.package com.szy.spring.bean;  
2.  
3.public class Property  
4.{  
5.    private String name;  
6.    private String ref;  
7.      
8.    public Property(String name, String ref)  
9.    {  
10.        super();  
11.        this.name = name;  
12.        this.ref = ref;  
13.    }  
14.    public String getName()  
15.    {  
16.        return name;  
17.    }  
18.    public void setName(String name)  
19.    {  
20.        this.name = name;  
21.    }  
22.    public String getRef()  
23.    {  
24.        return ref;  
25.    }  
26.    public void setRef(String ref)  
27.    {  
28.        this.ref = ref;  
29.    }  
30.      
31.}  
   
   
   
在Spring学习笔记（3）中，我们在读取xml文件时bean节点下面是不存在property节点的，因此在这里我们需要修改readXML()方法：
   
  
  
Java代码  
1./** 
2.     * 读取xml配置文件 
3.     * @param fileName 配置文件名 
4.     */  
5.    private void readXML(String fileName)  
6.    {  
7.        // 寻找配置文件  
8.        URL xmlPath = this.getClass().getClassLoader().getResource(fileName);  
9.        Document doc = null;  
10.        Element root = null;  
11.        try  
12.        {  
13.            SAXBuilder sb = new SAXBuilder(false);  
14.            doc = sb.build(new FileInputStream(new File(xmlPath.toURI())));  
15.            // 设置命名空间     
16.            Namespace xhtml = Namespace.getNamespace("xhtml",  
17.                    "http://www.springframework.org/schema/beans");  
18.            root = doc.getRootElement(); // 获取根元素     
19.            List<Element> bList = root.getChildren("bean", xhtml); //获取全部bean节点     
20.            for (Element beanElement : bList)// 遍历节点，取得每个节点的属性     
21.            {  
22.                String id = beanElement.getAttributeValue("id");  
23.                String className = beanElement.getAttributeValue("class");  
24.                //获得每个bean下面的属性  
25.                List<Element> pList = beanElement  
26.                        .getChildren("property", xhtml);  
27.                List<Property> propertyList = new ArrayList<Property>(); //存储属性信息  
28.                if (pList.size() > 0) //如果存在属性  
29.                {  
30.                    for (Element propertyElement : pList) //遍历属性节点  
31.                    {  
32.                        String name = propertyElement.getAttributeValue("name");  
33.                        String ref = propertyElement.getAttributeValue("ref");  
34.                        Property property = new Property(name, ref);  
35.                        propertyList.add(property); //保存属性节点  
36.                    }  
37.                }  
38.                Bean bean = new Bean(id, className, propertyList);  
39.                beanList.add(bean);  
40.            }  
41.  
42.        } catch (Exception e)  
43.        {  
44.            e.printStackTrace();  
45.        }  
46.    }  
   
 读取完配置文件后我们还是需要对bean进行实例化的，这方法和Spring学习笔记（3）中的instanceBeans()方法一样。下面就是我们需要给bean属性进行注入，实现方法如下：
   
  
  
Java代码  
1./** 
2.     * 为bean对象的属性注入值 
3.     */  
4.    public void injectObject()  
5.    {  
6.        for (Bean bean : beanList)  
7.        {  
8.            Object object = beanObject.get(bean.getId()); //获取bean的实例  
9.            if (object != null)  
10.            {  
11.                try  
12.                {  
13.                    PropertyDescriptor[] ps = Introspector.getBeanInfo(  
14.                            object.getClass()).getPropertyDescriptors();  //取得bean的属性描述  
15.                    for (Property property : bean.getPropertyList())  //获取bean节点的属性  
16.                    {  
17.                        for (PropertyDescriptor properdesc : ps)    
18.                        {  
19.                            if (property.getName().equals(properdesc.getName()))  
20.                            {  
21.                                Method setter = properdesc.getWriteMethod();//获取属性的setter方法 ,private  
22.                                if (setter != null)  
23.                                {  
24.                                    Object value = beanObject.get(property.getRef());  //取得值  
25.                                    setter.setAccessible(true);  //设置为允许访问  
26.                                    setter.invoke(object, value);//把引用对象注入到属性  
27.                                }  
28.                                break;  
29.                            }  
30.                        }  
31.                    }  
32.                } catch (Exception e)  
33.                {  
34.                    e.printStackTrace();  
35.                }  
36.            }  
37.        }  
   
   
   
我们进行测试：
   
  
  
Java代码  
1.MyClassPathXMLApplicationContext ctx=new MyClassPathXMLApplicationContext("applicationContext.xml");     
2.        UserService service=(UserService)ctx.getBean("userService");  
3.        service.show();  
   
   
   
运行输出
   
  
  
结果代码  
1.OracleDAO Implement  
   
 上面仅是简单的演示了Spring依赖注入的原理，但是Spring学习笔记（7）----装配各种集合类型的属性在实际操作中还需要考虑很对其它因素，在此就不进行讨论了。
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
Spring学习笔记（7）----装配各种集合类型的属性
---------------------------------------------
前面已经介绍了如何给属性注入对象，下面介绍一下如何装配集合类型的属性 
1.Set类型
   
  
  
Java代码  
1.private Set<String> sets=new HashSet<String>();  
2.//我们需要给它添加set方法  
3.public Set<String> getSets()  
4.    {  
5.        return sets;  
6.    }  
7.    public void setSets(Set<String> sets)  
8.    {  
9.        this.sets = sets;  
10.    }  
11.public Set<String> showSet()  
12.    {  
13.        return sets;  
14.    }  
   
 然后根据属性修改配置文件
   
  
  
Xml代码  
1.<bean id="userService" class="com.szy.spring.service.UserServiceImpl">  
2.        <property name="sets">  
3.            <set>  
4.                <value>Set1</value>  
5.                <value>Set2</value>  
6.                <value>Set3</value>  
7.            </set>      
8.        </property>  
9.  
10.</bean>  
   
 与以前不同的是我们在property下面添加了<set></set>
   
这样就能装配set类型的属性
   
2.List类型
   
List类型的属性和Set类型的方法一样，主要是把配置文件中的set修改成list。
   
  
  
Java代码  
1.private List<String> lists=new ArrayList<String>();  
2.public List<String> getLists()  
3.    {  
4.        return lists;  
5.    }  
6.    public void setLists(List<String> lists)  
7.    {  
8.        this.lists = lists;  
9.    }  
10.public List<String> showList()  
11.    {  
12.        return lists;  
13.    }  
   
 配置文件修改如下
   
  
  
Xml代码  
1.<bean id="userService"  class="com.szy.spring.service.UserServiceImpl">  
2.<property name="lists">  
3.            <list>  
4.                <value>List1</value>  
5.                <value>List2</value>  
6.                <value>List3</value>  
7.            </list>  
8.        </property>  
9.    </bean>  
   
3.Properties类型
   
  
  
Java代码  
1.private Properties properties=new Properties();  
2.public void setProperties(Properties properties)  
3.    {  
4.        this.properties = properties;  
5.    }  
6.public Properties getProperties()  
7.    {  
8.        return properties;  
9.    }  
10.public Properties showProperties()  
11.    {  
12.        return properties;  
13.    }  
   
 配置文件需要如下配置
   
  
  
Xml代码  
1.<bean id="userService" class="com.szy.spring.service.UserServiceImpl">  
2.<property name="properties">  
3.            <props>  
4.                <prop key="key1">Properties1</prop>  
5.                <prop key="key2">Properties2</prop>  
6.                <prop key="key3">Properties3</prop>  
7.            </props>  
8.        </property>  
9.    </bean>  
10.      
   
 4.Map类型
   
  
  
Java代码  
1.private Map<String, String> maps=new HashMap<String, String>();  
2.public List<String> getLists()  
3.    {  
4.        return lists;  
5.    }  
6.    public void setLists(List<String> lists)  
7.    {  
8.        this.lists = lists;  
9.    }  
10.public Map<String, String> showMaps()  
11.    {  
12.        return maps;  
13.    }  
   
 配置文件做相应的配置
   
  
  
Xml代码  
1.<bean id="userService" class="com.szy.spring.service.UserServiceImpl">  
2.lt;property name="maps">  
3.        <map>  
4.            <entry key="key1" value="Map1"></entry>  
5.            <entry key="key2" value="Map2"></entry>  
6.            <entry key="key3" value="Map3"></entry>  
7.        </map>  
8.    </property>  
9.</bean>  
   
   
   
这样就完成了对Map类型的属性进行装配。
  
  
  
  
  
  
  
  
Spring学习笔记（8）----属性注入的方式
--------------------------------------
Spring中属性注入的方式有三种：
   
1.使用属性setter方法注入
   
2.使用构造器注入
   
3.使用注解方式注入
   
   
   
使用属性setter方法注入
   
使用属性setter方法注入就是给属性添加set()方法，在前面都是使用这种方法。
   
  
  
Java代码  
1.package com.szy.spring.service;  
2.  
3.import com.szy.spring.dao.PersonDao;  
4.  
5.public class UserServiceImplBySetter implements UserService  
6.{  
7.    private PersonDao personDao;  
8.      
9.    public void show()  
10.    {  
11.        personDao.show();  
12.    }  
13.    public PersonDao getPersonDao()  
14.    {  
15.        return personDao;  
16.    }  
17.    public void setPersonDao(PersonDao personDao)  
18.    {  
19.        this.personDao = personDao;  
20.    }  
21.}  
   
   
   
然后在配置文件中如下配置
   
  
  
Xml代码  
1.<bean id="personDao" class="com.szy.spring.dao.PersonDaoBean"/>  
2.    <!-- 使用属性Setter方法注入配置 -->  
3.    <bean id="userService1" class="com.szy.spring.service.UserServiceImplBySetter">  
4.        <property name="personDao" ref="personDao"></property>  
5.    </bean>  
   
   
   
使用构造器注入
   
使用构造器注入就是在类中添加含参构造函数
   
  
  
Java代码  
1.package com.szy.spring.service;  
2.  
3.import com.szy.spring.dao.PersonDao;  
4.  
5.public class UserServiceImplConstructor implements UserService  
6.{  
7.    private PersonDao personDao;  
8.    private String name;  
9.      
10.    public UserServiceImplConstructor()  
11.    {  
12.    }  
13.  
14.    public UserServiceImplConstructor(PersonDao personDao, String name)  
15.    {  
16.        this.personDao = personDao;  
17.        this.name = name;  
18.    }  
19.  
20.    public void show()  
21.    {  
22.        personDao.show();  
23.        System.out.println("name属性："+name);  
24.    }  
25.}  
   
   
   
下面就是在配置文件中添加配置信息，给每个参数注入值
   
  
  
Xml代码  
1.<bean id="personDao" class="com.szy.spring.dao.PersonDaoBean"/>  
2.    <!-- 使用构造器参数方法注入配置 -->  
3.    <bean id="userService2" class="com.szy.spring.service.UserServiceImplConstructor">  
4.        <constructor-arg index="0" type="com.szy.spring.dao.PersonDao" ref="personDao"/>  
5.        <constructor-arg index="1" value="Kuka"/>  
6.    </bean>  
   
 注意：constructor-arg index是从0开始的
   
   
   
使用注解方式注入
   
如果使用前面的两种方法，配置文件将会显得很臃肿，因此我们可以使用注解的方式注入，使用注解方式注入有两种方法，第一种使用javax.annotation.Resource中提供的注解方式方法如下：
   
  
  
Java代码  
1.package com.szy.spring.service;  
2.  
3.import javax.annotation.Resource;  
4.  
5.import com.szy.spring.dao.PersonDao;  
6.  
7.public class UserServiceImplByAnnotation4Resource implements UserService  
8.{  
9.    //@Resource默认是按照名称装配，找不到与名称匹配的bean时按类型装配  
10.    @Resource(name="personDao")private PersonDao personDao;  
11.  
12.    public void show()  
13.    {  
14.        personDao.show();  
15.    }  
16.//  下面方法同样可以  
17.//  @Resource  
18.//  public void setPersonDao(PersonDao personDao)  
19.//  {  
20.//      this.personDao = personDao;  
21.//  }  
22.      
23.}  
   
   
   
此时配置文件要做相应的改变
   
  
  
Xml代码  
1.<?xml version="1.0" encoding="UTF-8"?>  
2.<beans xmlns="http://www.springframework.org/schema/beans"  
3.    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.    xmlns:context="http://www.springframework.org/schema/context"  
5.    xmlns:tx="http://www.springframework.org/schema/tx"  
6.    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
7.                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd  
8.                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">  
9.    <context:annotation-config/>  
10.    <bean id="personDao" class="com.szy.spring.dao.PersonDaoBean"/>  
11.    <bean id="userService" class="com.szy.spring.service.UserServiceImplByAnnotation4Autowired">  
12.    </bean>  
13.</beans>  
   
   
   
 注意添加这句配置信息
   
<context:annotation-config/>
  
   
第二中方式就是使用spring提供的注解方式
   
org.springframework.beans.factory.annotation.Autowired;
   
注入使用时需要导入spring目录lib\j2ee\common-annotations.jar这个包
   
使用方法如下：
   
  
  
Java代码  
1.package com.szy.spring.service;  
2.  
3.import org.springframework.beans.factory.annotation.Autowired;  
4.import org.springframework.beans.factory.annotation.Qualifier;  
5.  
6.import com.szy.spring.dao.PersonDao;  
7.  
8.public class UserServiceImplByAnnotation4Autowired implements UserService  
9.{  
10.    //@Autowired默认使用类型进行装配，  
11.    @Autowired private PersonDao personDao;  
12.//  如果使用按名称进行装配，则需要如下  
13.//  @Autowired @Qualifier("personDao")private PersonDao personDao;  
14.    public void show()  
15.    {  
16.        personDao.show();  
17.    }  
18.      
19.}  
   
   
   
配置文件和上面一样。
   
   
   
在使用时建议使用@Resource，因为@Resource不依赖于spring框架。
  
  
  
  
  
  
Spring学习笔记（9）----让Spring自动扫描和管理Bean
-------------------------------------------------
  
  
  
Java代码  
1.package com.szy.spring.service;  
2.  
3.import org.springframework.stereotype.Service;  
4.  
5.import com.szy.spring.dao.PersonDao;  
6.@Service("service")  
7.public class UserServiceImpl implements UserService  
8.{  
9.    private PersonDao personDaoBean;  
10.      
11.    public void show()  
12.    {  
13.        personDaoBean.show();  
14.    }  
15.  
16.    public void setPersonDaoBean(PersonDao personDaoBean)  
17.    {  
18.        this.personDaoBean = personDaoBean;  
19.    }  
20.}  
   
 在前面的例子中，都是使用XML的bean定义来使用组件，在大的项目中，通常会有上百个组件，如果这些组件采用xml的bean定义来配置，显然会使配置文件显得很臃肿，查找和维护起来不方便。Spring2.5为我们引入了组件自动扫描机制，它可以在类路径下寻找标记了@Component、@Service、@Controller、@Repository注解的类，并把这些类纳入到spring容器中管理，它的作用和在xml中使用bean节点配置组件一样。要使用自动扫描机制，我们需要把配置文件如下配置：
   
  
  
Xml代码  
1.<?xml version="1.0" encoding="UTF-8"?>  
2.<beans xmlns="http://www.springframework.org/schema/beans"  
3.    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.    xmlns:context="http://www.springframework.org/schema/context"  
5.    xmlns:tx="http://www.springframework.org/schema/tx"  
6.    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
7.                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd  
8.                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
9.    <context:component-scan base-package="com.szy.spring"></context:component-scan>  
10.</beans>  
   
 其中base-package为需要扫描的包（包括子包）
   
@Service用于标注业务层的组件，@Controller用于标注控制层组件（如struts中的action），@Repository用于标注数据访问组件，即DAO组件，而@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。但是在目前的spring版本中，这几个注解的作用是一样的，但是在以后可能会进行区分。
   
   
   
下面把先前的例子修改一下：
   
首先是PersonDaoBean类，修改如下
   
  
  
Java代码  
1.package com.szy.spring.dao;  
2.  
3.import org.springframework.stereotype.Repository;  
4.  
5.@Repository  
6.//告诉spring这个类要交给spring管理，  
7.public class PersonDaoBean implements PersonDao  
8.{  
9.    public void show()  
10.    {  
11.        System.out.println("执行PersonDaoBean中的add()方法");  
12.    }  
13.}  
   
   
   
然后是UserServiceImpl类
   
  
  
Java代码  
1.package com.szy.spring.service;  
2.  
3.import org.springframework.stereotype.Service;  
4.  
5.import com.szy.spring.dao.PersonDao;  
6.@Service  
7.//把这个类交给spring管理，作为服务了。  
8.public class UserServiceImpl implements UserService  
9.{  
10.    private PersonDao personDaoBean;  
11.      
12.    public void show()  
13.    {  
14.        personDaoBean.show();  
15.    }  
16.  
17.    public void setPersonDaoBean(PersonDao personDaoBean)  
18.    {  
19.        this.personDaoBean = personDaoBean;  
20.    }  
21.  
22.    public PersonDao getPersonDaoBean()  
23.    {  
24.        return personDaoBean;  
25.    }  
26.}  
   
   
   
   
   
 下面我们进行测试，原来的测试代码是userServiceImpl 
  
  
  
Java代码  
1.ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");  
2.        UserService service=(UserService)ctx.getBean("userService");  
3.        service.show();  
   
   
   
其中userService是我们在配置文件中配置的bean的id。但是如今我们并没有id这个属性，在spring2.5中，默认的id是类的名称，但是开后是小写，也就是userServiceImpl，因此测试代码应修改如下：
   
  
  
Java代码  
1.AbstractApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");  
2.        UserService service=(UserService)ctx.getBean("userServiceImpl");  
3.        System.out.println(service);  
   
   
   
如果我们想自己命名的话，则只需在注解后加上括号，里面写入你希望的名字，如
   
@Service("userService")。
   
   
   
在spring中默认的是之生成一个bean实例，如果我们想每次调用都产生一个实例，则标注需如下配置
   
@Service @Scope("prototype")
   
   
   
在xml中我们还可以配置初始化方法和销毁方法，使用标注后只需如下标注
   
  
  
Java代码  
1.@PostConstruct  
2.    public void init()  
3.    {  
4.        System.out.println("初始化");  
5.    }  
6.    @PreDestroy  
7.    public void destory()  
8.    {  
9.        System.out.println("销毁");  
10.    }  
   
   
   
 使用注解后，我们的xml文件变得十分简单，因此建议Spring学习笔记（10）----公共属性的注入配置大家在以后的开发中使用注解。
  
  
  
  
  
  
  
  
  
  
Spring学习笔记（10）----公共属性的注入配置
-------------------------------------------
假设我们定义了四个bean类，其代码分别如下：
   
  
  
Java代码  
1.package com.szy.spring.bean;  
2.  
3.public class Bean1 {  
4.    private Bean2 bean2;  
5.    private Bean3 bean3;  
6.    private Bean4 bean4;  
7.  
8.    public Bean2 getBean2()  
9.    {  
10.        return bean2;  
11.    }  
12.    public void setBean2(Bean2 bean2)  
13.    {  
14.        this.bean2 = bean2;  
15.    }  
16.    public Bean3 getBean3()  
17.    {  
18.        return bean3;  
19.    }  
20.    public void setBean3(Bean3 bean3)  
21.    {  
22.        this.bean3 = bean3;  
23.    }  
24.    public Bean4 getBean4()  
25.    {  
26.        return bean4;  
27.    }  
28.    public void setBean4(Bean4 bean4)  
29.    {  
30.        this.bean4 = bean4;  
31.    }  
32.}  
   
   
   
   
   
  
  
Java代码  
1.package com.szy.spring.bean;  
2.  
3.public class Bean2  
4.{  
5.    private int id;  
6.    private String name;  
7.    private String password;  
8.  
9.    public int getId()  
10.    {  
11.        return id;  
12.    }  
13.    public void setId(int id)  
14.    {  
15.        this.id = id;  
16.    }  
17.    public String getName()  
18.    {  
19.        return name;  
20.    }  
21.    public void setName(String name)  
22.    {  
23.        this.name = name;  
24.    }  
25.    public String getPassword()  
26.    {  
27.        return password;  
28.    }  
29.    public void setPassword(String password)  
30.    {  
31.        this.password = password;  
32.    }  
33.}  
   
   
   
   
   
  
  
Java代码  
1.package com.szy.spring.bean;  
2.  
3.public class Bean3  
4.{  
5.    private int id;  
6.    private String name;  
7.  
8.    public int getId()  
9.    {  
10.        return id;  
11.    }  
12.    public void setId(int id)  
13.    {  
14.        this.id = id;  
15.    }  
16.    public String getName()  
17.    {  
18.        return name;  
19.    }  
20.    public void setName(String name)  
21.    {  
22.        this.name = name;  
23.    }  
24.}  
   
   
   
   
   
  
  
Java代码  
1.package com.szy.spring.bean;  
2.  
3.public class Bean4  
4.{  
5.    private int age;  
6.  
7.    public int getAge()  
8.    {  
9.        return age;  
10.    }  
11.    public void setAge(int age)  
12.    {  
13.        this.age = age;  
14.    }  
15.}  
   
   
   
按照正常的思路，我们下面就要给每个类进行属性的注入，配置文件如下设置：
   
  
  
Xml代码  
1.<?xml version="1.0" encoding="UTF-8"?>  
2.<beans xmlns="http://www.springframework.org/schema/beans"  
3.    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.    xmlns:context="http://www.springframework.org/schema/context"  
5.    xmlns:tx="http://www.springframework.org/schema/tx"  
6.    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
7.                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd  
8.                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
9.    <bean id="bean1" class="com.szy.spring.bean.Bean1">  
10.        <property name="bean2" ref="bean2"/>  
11.        <property name="bean3">  
12.            <ref bean="bean3"/>  
13.        </property>     
14.        <property name="bean4" ref="bean4"/>  
15.    </bean>  
16.      
17.    <bean id="bean2" class="com.szy.spring.bean.Bean2">  
18.        <property name="id" value="100"/>  
19.        <property name="name">  
20.            <value>kuka</value>  
21.        </property>  
22.        <property name="password" value="123"/>  
23.    </bean>  
24.      
25.    <bean id="bean3" class="com.szy.spring.bean.Bean3">  
26.        <property name="id" value="100"/>  
27.        <property name="name" value="kuka"/>  
28.    </bean>  
29.       
30.    <bean id="bean4" class="com.szy.spring.bean.Bean4">  
31.        <property name="age" value="22"/>  
32.    </bean>  
33.</beans>  
   
   
   
我们进行测试：
   
  
  
Java代码  
1.@Test  
2.    public void testMethod() throws Exception  
3.    {  
4.        ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");  
5.        Bean1 bean1 = (Bean1)ctx.getBean("bean1");  
6.          
7.        System.out.println("bean1.bean2.id=" + bean1.getBean2().getId());  
8.        System.out.println("bean1.bean2.name=" + bean1.getBean2().getName());  
9.        System.out.println("bean1.bean2.password=" + bean1.getBean2().getPassword());  
10.        System.out.println("bean1.bean3.id=" + bean1.getBean3().getId());  
11.        System.out.println("bean1.bean3.name=" + bean1.getBean3().getName());  
12.        System.out.println("bean1.bean4.age=" + bean1.getBean4().getAge());  
13.    }  
   
   
   
正常输出我们所预期的信息，但是我们观察发现bean2和bean3的部分属性的配置信息是相同的，这仅是两个bean，如果是多个bean的话我们要修改就好修改多处，因此我们可以把这些公共的部分提出出来，进行抽象。这个在Spring中是支持的。我们在建立一个配置文件，命名为：applicationCommon.xml，其内容如下配置
   
  
  
Xml代码  
1.<?xml version="1.0" encoding="UTF-8"?>  
2.<beans xmlns="http://www.springframework.org/schema/beans"  
3.    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.    xmlns:context="http://www.springframework.org/schema/context"  
5.    xmlns:tx="http://www.springframework.org/schema/tx"  
6.    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
7.                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd  
8.                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
9.     <bean id="beanAbstract" abstract="true">  
10.        <property name="id" value="100"/>  
11.        <property name="name" value="kuka"/>  
12.   </bean>           
13.     
14.   <bean id="bean2" class="com.szy.spring.bean.Bean2" parent="beanAbstract">  
15.            <property name="password" value="123"/>  
16.   </bean>          
17.     
18.   <bean id="bean3" class="com.szy.spring.bean.Bean3" parent="beanAbstract"/>  
19.      
20.</beans>  
   
 beanAbstract就是我们抽象出来的，设置abstract="true"属性后就不需要指定class属性。
   
我们把原来配置文件里的关于bean2和bean3节点注释掉。
   
下面进行测试，在这里要注意由于我们使用了两个配置文件，因此我们在读取是要写两个配置文件名。我们查看ClassPathXmlApplicationContext源文件发现其有个构造函数参数是string数组，因此我们可以把这个配置文件名放在数组里面。此外我们还有另外一种实现方法，两个配置文件一个叫applicationContext.xml，另一个applicationCommon.xml，公共部分是applicationC*.xml，下面我们就可以这样进行测试：
   
  
  
Java代码  
1.@Test  
2.    public void testMethod() throws Exception  
3.    {  
4.        ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationC*.xml");  
5.        Bean1 bean1 = (Bean1)ctx.getBean("bean1");  
6.          
7.        System.out.println("bean1.bean2.id=" + bean1.getBean2().getId());  
8.        System.out.println("bean1.bean2.name=" + bean1.getBean2().getName());  
  
  
9.        System.out.println("bean1.bean2.password=" + bean1.getBean2().getPassword());  
10.        System.out.println("bean1.bean3.id=" + bean1.getBean3().getId());  
11.        System.out.println("bean1.bean3.name=" + bean1.getBean3().getName());  
12.        System.out.println("bean1.bean4.age=" + bean1.getBean4().getAge());  
13.    }  
   
   
   
如果我们bean2的name属性的值不是kuka，那么我们只需在applicationCommon.xml文件的bean2节点下再添加property属性即可
   
  
  
Xml代码  
1.<property name="name" value="coolszy"/>  
  
  
  
  
  
  
  
  
  
  
  
  
Spring学习笔记（11）----自定义属性编辑器
-------------------------------------------
前面我们所定义的属性都是几本的属性，如果我们定义一个属性是Date类型，例如如下类中：
   
  
  
Java代码  
1.package com.szy.spring.bean;  
2.  
3.import java.util.Date;  
4.  
5.public class Bean {  
6.    private Date date;  
7.  
8.    public Date getDate()  
9.    {  
10.        return date;  
11.    }  
12.    public void setDate(Date date)  
13.    {  
14.        this.date = date;  
15.    }  
16.}  
   
 按照我们以前学过的知识我们需要在配置文件中给该属性注入值
   
  
  
Xml代码  
1.<bean id="bean" class="com.szy.spring.bean.Bean">  
2.        <property name="date" value="2009-11-21"/>  
3.    </bean>  
   
 下面我们测试是否成功注入值
   
  
  
Java代码  
1.ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");  
2.        Bean bean = (Bean)ctx.getBean("bean");  
3.        System.out.println(bean.getDate());  
   
 运行包如下异常
   
  
  
Exception代码  
1.org.springframework.beans.factory.BeanCreationException: Error creating bean with name ‘bean‘ defined in class path resource [applicationContext.xml]: Initialization of bean failed; nested exception is org.springframework.beans.TypeMismatchException: Failed to convert property value of type [java.lang.String] to required type [java.util.Date] for property ‘date‘; nested exception is java.lang.IllegalArgumentException: Cannot convert value of type [java.lang.String] to required type [java.util.Date] for property ‘date‘: no matching editors or conversion strategy found  
   
 通过错误提示信息我们得知spring不能将string转换成date类型，没有匹配的编辑器或者转换机制。
如果想实现string转换成Date，那么我们自己需要写一个属性编辑器
   
我们新建一个类DatePropertyEditor，这个类要继承PropertyEditorSupport类。
我们需要复写这个类中的setAsText方法，其中text参数就是配置文件中的值。我们的任务就是把text转换成date类型的值。
   
  
  
Java代码  
1.package com.szy.spring.util;  
2.  
3.import java.beans.PropertyEditorSupport;  
4.import java.text.SimpleDateFormat;  
5.import java.util.Date;  
6.  
7.public class DatePropertyEditor extends PropertyEditorSupport  
8.{  
9.  
10.    @Override  
11.    public void setAsText(String text) throws IllegalArgumentException  
12.    {  
13.        String format="yyyy-MM-dd";  
14.        SimpleDateFormat sdf=new SimpleDateFormat(format);  
15.        try  
16.        {  
17.            Date date=sdf.parse(text);  
18.            this.setValue(date);  //把转换后的值传过去  
19.        } catch (Exception e)  
20.        {  
21.            e.printStackTrace();  
22.        }  
23.    }  
24.  
25.}  
   
写完编辑器后我们还需要把编辑器注入到spring中。 为了方便管理我们再新建一个配置文件applicationEditor.xml，用来配置属性编辑器
   
  
  
Xml代码  
1.<?xml version="1.0" encoding="UTF-8"?>  
2.<beans xmlns="http://www.springframework.org/schema/beans"  
3.    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.    xmlns:context="http://www.springframework.org/schema/context"  
5.    xmlns:tx="http://www.springframework.org/schema/tx"  
6.    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
7.                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd  
8.                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
9.    <bean id="customEditorConfigurer" class="org.springframework.beans.factory.config.CustomEditorConfigurer">  
10.        <!-- 把值注入到CustomEditorConfigurer的 Map类型的customEditors属性-->  
11.        <property name="customEditors">  
12.            <map>  
13.                <entry key="java.util.Date">  
14.                    <!-- 内部bean只供自己使用 -->  
15.                    <bean class="com.szy.spring.util.DatePropertyEditor"/>  
16.                </entry>  
17.            </map>  
18.        </property>  
19.    </bean>  
20.      
21.</beans>  
   
   
   
下面我们修改下测试代码已读取所有的配置文件
   
  
  
Java代码  
1.ApplicationContext ctx=new ClassPathXmlApplicationContext("application*.xml");  
2.        Bean bean = (Bean)ctx.getBean("bean");  
3.        System.out.println(bean.getDate());  
   
   
   
最后测试，成功输出时间。
   
刚才我们在配置文件中时间的格式是2009-11-21，如果我们修改成2009/11/21呢？
   
运行报错:Unparseable date: "2009/11/21"
   
这时我们需要修改属性编辑器类文件的格式了，很麻烦。既然spring支持注入，那么我们为什么不对格式进行注入呢？
   
修改属性编辑器类：
   
  
  
Java代码  
1.package com.szy.spring.util;  
2.  
3.import java.beans.PropertyEditorSupport;  
4.import java.text.SimpleDateFormat;  
5.import java.util.Date;  
6.  
7.public class DatePropertyEditor extends PropertyEditorSupport  
8.{  
9.  
10.    private String format;  
11.    @Override  
12.    public void setAsText(String text) throws IllegalArgumentException  
13.    {  
14.          
15.        SimpleDateFormat sdf=new SimpleDateFormat(format);  
16.        try  
17.        {  
18.            Date date=sdf.parse(text);  
19.            this.setValue(date);  //把转换后的值传过去  
20.        } catch (Exception e)  
21.        {  
22.            e.printStackTrace();  
23.        }  
24.    }  
25.    public String getFormat()  
26.    {  
27.        return format;  
28.    }  
29.    public void setFormat(String format)  
30.    {  
31.        this.format = format;  
32.    }  
33.}  
   
   
   
同时给该类对应的bean添加属性节点
   
  
  
Xml代码  
1.<bean class="com.szy.spring.util.DatePropertyEditor">  
2.                        <property name="format" value="yyyy/MM/dd"></property>  
3.                    </bean>  
   
   
   
下次只要我们修改配置文件即可，灵活性很大。
  
  
  
  
  
  
  
  
Spring学习笔记（12）----静态代理模式分析演示
--------------------------------------------
代理模式分为静态代理和动态代理。静态代理就是我们自己定义的代理类，动态代理是程序在运行时生成的代理类。
   
下面演示下静态代理类。首先我们要定义一个接口：
   
  
  
Java代码  
1.package com.szy.spring;  
2.  
3.public interface UserManager  
4.{  
5.    public void addUser(String username,String password);  
6.    public void deleteUser(int userId);  
7.    public void modifyUser(int userId,String username,String password);  
8.    public void findUser(int userId);  
9.}  
   
 比较常见的对用户进行增删改查。
   
下面我们常见一个实现类，实现这个接口。
   
  
  
Java代码  
1.package com.szy.spring;  
2.  
3.public class UserManagerImpl implements UserManager  
4.{  
5.  
6.    public void addUser(String username, String password)  
7.    {  
8.        System.out.println("--------UserManagerImpl.addUser()----------");  
9.    }  
10.  
11.    public void deleteUser(int userId)  
12.    {  
13.        System.out.println("--------UserManagerImpl.deleteUser()----------");  
14.    }  
15.  
16.    public void findUser(int userId)  
17.    {  
18.        System.out.println("--------UserManagerImpl.findUser()----------");  
19.    }  
20.  
21.    public void modifyUser(int userId, String username, String password)  
22.    {  
23.        System.out.println("--------UserManagerImpl.modifyUser()----------");  
24.    }  
25.}  
   
   
   
每个方法仅仅是输出一句话。
   
下面我们定义一个客户端类来调用这些方法。
   
  
  
Java代码  
1.package com.szy.spring;  
2.  
3.public class Client  
4.{  
5.    public static void main(String[] args)  
6.    {  
7.        UserManager userManager=new UserManagerImpl();  
8.        userManager.addUser("coolszy", "kuka");  
9.    }  
10.}  
   
   
   
运行正常输出我们期望的结果。
   
下面我们需要加入安全性检查，就是调用方法前我们需要进行验证，比较常见的就是权限验证，验证用户是否拥有权限，
   
比较常见的做法就是在UserManagerImpl类中定义一个检查安全性的方法：
   
  
  
Java代码  
1.public void checkSecurity()  
2.    {  
3.        System.out.println("--------UserManagerImpl.checkSecurity()----------");  
4.    }  
   
 然后在每个方法中都要调用这个方法。但是这样不符合开-闭原则（Open-Closed principle,简称OCP）。因此我们可以使用代理类来实现这个功能。代理模式很显著的特征就是和目标对象的接口一致。在代理类中我们可以控制目标对象。要控制目标对象我们必须有一个目标对象的引用。为了灵活我们可以把目标对象传到方法中，而不是在方法中实例化。同时我们把安全性检查的代码也放到代理类中，在调用每个方法之前调用这个检查方法，通过代理对我们以前的类没有破坏。
   
  
  
Java代码  
1.package com.szy.spring;  
2.  
3.public class UserManagerImplProxy implements UserManager  
4.{  
5.    private UserManager userManager;  
6.      
7.    public UserManagerImplProxy(UserManager userManager)  
8.    {  
9.        this.userManager = userManager;  
10.    }  
11.    public void addUser(String username, String password)  
12.    {  
13.        checkSecurity();  
14.        this.userManager.addUser(username, password);  
15.    }  
16.    public void deleteUser(int userId)  
17.    {  
18.        checkSecurity();  
19.        this.userManager.deleteUser(userId);  
20.    }  
21.    public String findUser(int userId)  
22.    {  
23.        checkSecurity();  
24.        return this.userManager.findUser(userId);  
25.    }  
26.    public void modifyUser(int userId, String username, String password)  
27.    {  
28.        checkSecurity();  
29.        this.userManager.modifyUser(userId, username, password);  
30.    }  
31.    public void checkSecurity()  
32.    {  
33.        System.out.println("--------UserManagerImpl.checkSecurity()----------");  
34.    }  
35.}  
   
   
   
下面修改客户端类。
   
  
  
Java代码  
1.UserManager userManager=new UserManagerImplProxy(new UserManagerImpl());  
2.        userManager.addUser("coolszy", "kuka");  
   
   
   
这样总的来说比较灵活。这个依赖关系是我们自己做的，我们完全可以交给spring处理。
   
按照上面的这种做法有一个缺点，如果接口中方法很多，那么我们实现每一个方法都要添加检查方法checkSecurity()，影响了我们的业务处理。采用静态代理模式我们是没法解决的，这时我们需要使用AOP思想。
   
   
  
  
  
  
Spring学习笔记（13）----动态代理模式分析演示
-----------------------------------------------
上一节演示的是静态代理模式，本节演示的是静态代理模式，既然是动态，那么就不存在UserManagerImplProxy类。
   
使用动态代理我们需要声明一个类SecurityHandler，这个类要实现InvocationHandler接口。
   
在类中定义一个产生动态代理的方法newProxy();同时把我们验证的代码放到这个类中。通过SecurityHandler，当我们调用方法时默认会调用SecurityHandler类invoke方法，我们在这个方法中进行安全性检查，检查通过后在调用真实的方法。需要注意的是目标对象接口中的部分方法是存在返回值的。
   
  
  
Java代码  
1.package com.szy.spring;  
2.  
3.import java.lang.reflect.InvocationHandler;  
4.import java.lang.reflect.Method;  
5.import java.lang.reflect.Proxy;  
6.  
7.public class SecurityHandler implements InvocationHandler  
8.{  
9.    private Object targetObject;  
10.      
11.    public Object newProxy(Object targetObject)  
12.    {  
13.        this.targetObject=targetObject;  
14.        //返回动态代理  
15.        return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),  
16.                                      targetObject.getClass().getInterfaces(),  
17.                                      this);  
18.    }  
19.    public Object invoke(Object proxy, Method method, Object[] args)  
20.            throws Throwable  
21.    {  
22.        checkSecurity();  
23.        Object ret=null;  
24.        try  
25.        {  
26.            //调用目标对象的真实方法  
27.            ret=method.invoke(this.targetObject, args);  
28.            //ret接受存在的返回值，不存在返回值则为Null  
29.        } catch (Exception e)  
30.        {  
31.            e.printStackTrace();  
32.        }  
33.        return null;  
34.    }  
35.    public void checkSecurity()  
36.    {  
37.        System.out.println("--------UserManagerImpl.checkSecurity()----------");  
38.    }  
39.}  
   
   
   
使用这种方式维护起来相对比较好，我想进行安全性检查就进行，不想就不进行，很方便。
   
下面进行客户端调用
   
  
  
Java代码  
1.package com.szy.spring;  
2.  
3.public class Client  
4.{  
5.    public static void main(String[] args)  
6.    {  
7.        SecurityHandler handler=new SecurityHandler();  
8.        //创建代理对象  
9.        UserManager userManager=(UserManager)handler.newProxy(new UserManagerImpl());  
10.        userManager.addUser("coolszy", "kuka");  
11.    }  
12.}  
  
  
  
  
  
Spring学习笔记（14）----使用CGLIB实现AOP功能
-----------------------------------------------
  
接着这上面的例子，在上面的例子中我们的UserManagerImpl类是实现了UserManager接口，如果UserManagerImpl没有实现任何接口要怎么办呢？应为创建代理对象时我们需要指定接口的。
   
  
  
Java代码  
1.Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),  
2.                                      targetObject.getClass().getInterfaces(),  
3.                                      this);  
   
   
   
由于没有时间接口，因此我们是不能这样创建代理接口的，这是我们需要借助第三方包来实现。在spring中提供了cglib-nodep-2.1_3.jar包。我们通过cglib创建代理对象。
   
下面就通过实例演示通过cglib创建代理对象。
   
   
   
首先创建CGlibProxyFactory，实现MethodInterceptor接口，接口中有一个intercept方法，当代理对象的方法被调用时会调用这个方法。
   
  
  
Java代码  
1.package com.szy.spring;  
2.  
3.import java.lang.reflect.Method;  
4.import net.sf.cglib.proxy.Enhancer;  
5.import net.sf.cglib.proxy.MethodInterceptor;  
6.import net.sf.cglib.proxy.MethodProxy;  
7.  
8.  
9.public class CGlibProxyFactory implements MethodInterceptor  
10.{  
11.    private Object targetObject;  
12.      
13.    public Object newProxy(Object targetObject)  
14.    {  
15.        this.targetObject=targetObject;  
16.        Enhancer enhancer=new Enhancer();  
17.        enhancer.setSuperclass(this.targetObject.getClass());  
18.        enhancer.setCallback(this);  
19.        //返回代理对象  
20.        return enhancer.create();  
21.    }  
22.  
23.    /** 
24.     * proxy        带来对象本身 
25.     * method       被拦截到的方法 
26.     * args          方法的参数 
27.     * methodProxy  方法的代理对象 
28.     */  
29.    public Object intercept(Object proxy, Method method, Object[] args,  
30.            MethodProxy methodProxy) throws Throwable  
31.    {  
32.        checkSecurity();  
33.        Object ret=null;  
34.        try  
35.        {  
36.            //调用目标对象的真实方法  
37.            ret=method.invoke(this.targetObject, args);  
38.            //ret接受存在的返回值，不存在返回值则为Null  
39.        } catch (Exception e)  
40.        {  
41.            e.printStackTrace();  
42.        }  
43.        return ret;  
44.    }  
45.    public void checkSecurity()  
46.    {  
47.        System.out.println("--------UserManagerImpl.checkSecurity()----------");  
48.    }  
49.}  
   
   
   
其实整个代码很前面的很相似，只是创建代理对象的方法不一样。
   
测试代码：
   
  
  
Java代码  
1.CGlibProxyFactory factory=new CGlibProxyFactory();  
2.        //创建代理对象，这是这个代理对象是UserManagerImpl的子类  
3.        UserManagerImpl userManager=(UserManagerImpl)factory.newProxy(new UserManagerImpl());  
4.        userManager.addUser("coolszy", "kuka");  
   
   
   
上面演示的几个事例是不借助与任何框架的情况下实现AOP的方法。 
  
  
  
  
  
  
  
Spring学习笔记（15）----使用Spring的注解方式实现AOP
-----------------------------------------------------
下面介绍使用Spring框架进行AOP编程。
   
首先我们需要导入需要的jar包:
   
1.aspectjrt.jar
   
2.aspectjweaver.jar
   
3.cglib-nodep-2.1_3.jar
   
   
   
在spring中有两种方式实现面向切面编程，一种是基于XML配置，另一种是使用注解份额方式，在实际开放中我们可以任选其中的一种即可。
   
   
   
首先介绍下使用注解方式进行AOP开发。
   
要使用注解方式，我们需要打开注解处理器
   
  
  
Xml代码  
1.<aop:aspectj-autoproxy/>  
   
我们还是使用前面介绍的接口：
   
   
   
  
  
Java代码  
1.package com.szy.spring;  
2.  
3.public interface UserManager  
4.{  
5.  
6.    public abstract void addUser(String username, String password);  
7.  
8.    public abstract void deleteUser(int userId);  
9.  
10.    public abstract String findUser(int userId);  
11.  
12.    public abstract void modifyUser(int userId, String username, String password);  
13.  
14.}  
   
   
   
实现这个接口:
   
  
  
Java代码  
1.package com.szy.spring;  
2.  
3.public class UserManagerImpl implements UserManager   
4.{  
5.  
6.    public void addUser(String username, String password)  
7.    {  
8.        System.out.println("--------UserManagerImpl.addUser()----------");  
9.    }  
10.  
11.    public void deleteUser(int userId)  
12.    {  
13.        System.out.println("--------UserManagerImpl.deleteUser()----------");  
14.    }  
15.  
16.    public String findUser(int userId)  
17.    {  
18.        System.out.println("--------UserManagerImpl.findUser()----------");  
19.        return null;  
20.    }  
21.  
22.    public void modifyUser(int userId, String username, String password)  
23.    {  
24.        System.out.println("--------UserManagerImpl.modifyUser()----------");  
25.    }  
26.}  
   
   
   
下面我们定义一个切面类，由于我们使用的是注解方式，因此我们使用@Aspect来标识它是切面类。在切面类中我们要定义切入点，切入点是用来定义我们要拦截的方法。在切入点定义中使用了AOP表达式语言，下面通过实例简单解释一下：
   
   
   
  
  
表达式解释代码  
1.@Pointcut("execution (* com.szy.spring..*.*(..))")  
2.execution:代表执行  
3.第一个*:代表返回值类型，使用*代表任何类型的返回值  
4.com.szy.spring:代表包名  
5...:代表其底下的子包也进行拦截  
6.第二个*:代表对哪个类进行拦截，*代表所有类  
7.第三个*:代表方法  
8.(..):代表方法的蚕食有无都可以  
   
   
   
现在我们要对UserManagerImpl类下的所有方法进行拦截，则切入点如下表示：
   
  
  
Java代码  
1.@Pointcut("execution (* com.szy.spring.UserManagerImpl.*(..))")  
2.  
3.private void anyMethod()  //定义切入点  
4. {  
5. }  
   
   
   
其中切入点的名称是下面方法的名称aynMethod()，包括括号。
   
   
   
下面我们定义通知，通知分为前置通知、后置通知、意外通知、等。通知分为前置通知、后置通知、意外通知、最终通知和环绕通知等。
   
演示前置通知，
   
  
  
Java代码  
1.@Before("anyMethod()") //括号内为切入点名称  
2.  public void doBefore()  
3.  {  
4.   System.out.println("----------------执行前置通知-----------------");  
5.  }  
6.   
7.  @AfterReturning("anyMethod()")  
8.  public void doAfterReturning()  
9.  {  
10.   System.out.println("----------------执行后置通知-----------------");  
11.  }  
   
  
  
Java代码  
1. @After("anyMethod()")  
2. public void doAfter()  
3. {  
4.  System.out.println("----------------执行最终通知-----------------");  
5. }  
6.   
7.  @AfterThrowing("anyMethod()")  
8.  public void doAfterThrowing()  
9.  {  
10.   System.out.println("----------------执行意外通知-----------------");  
11.  }  
12.    
13. @Around("anyMethod()")  
14. public Object doAround(ProceedingJoinPoint pjp) throws Throwable  
15. {  
16.  System.out.println("----------------进入判断方法-----------------");  
17.  Object result=pjp.proceed();  //该方法必须被执行  
18.  System.out.println("----------------退出判断方法-----------------");  
19.  return result;  
20. }  
   
   
   
 我们把切面交给spring管理，要交给spring管理我们可以在配置文件同进行bean配置，或者使用扫描的方式。
   
  
  
Xml代码  
1.<bean id="interceptor" class="com.szy.spring.Interceptor"/>  
   
 下面我们进行测试
   
  
  
Java代码  
1.ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");  
2.        UserManager manager=(UserManager)context.getBean("userManager");  
3.        manager.addUser("coolszy", "kuka");  
   
   
   
按照我们的设计，输入的结果应为
   
----------------执行前置通知-----------------
----------------进入判断方法-----------------
--------UserManagerImpl.addUser()----------
----------------执行后置通知-----------------
----------------执行最终通知-----------------
----------------退出判断方法-----------------
  
  
  
  
  
  
Spring学习笔记(16)----使用Spring配置文件实现AOP
----------------------------------------------
  
前面介绍了使用注解的方式，下面介绍使用配置文件的方式实现AOP。
   
使用配置方式，Interceptor类中不包含任何注解。
   
  
  
Java代码  
1.package com.szy.spring;  
2.  
3.import org.aspectj.lang.ProceedingJoinPoint;  
4.  
5.public class Interceptor  
6.{  
7.    public void doBefore()  
8.    {  
9.        System.out.println("----------------执行前置通知-----------------");  
10.    }  
11.      
12.    public void doAfterReturning()  
13.    {  
14.        System.out.println("----------------执行后置通知-----------------");  
15.    }  
16.      
17.    public void doAfter()  
18.    {  
19.        System.out.println("----------------执行最终通知-----------------");  
20.    }  
21.      
22.    public void doAfterThrowing()  
23.    {  
24.        System.out.println("----------------执行意外通知-----------------");  
25.    }  
26.      
27.    public Object doAround(ProceedingJoinPoint pjp) throws Throwable  
28.    {  
29.        System.out.println("----------------进入判断方法-----------------");  
30.        Object result=pjp.proceed();  //该方法必须被执行  
31.        System.out.println("----------------退出判断方法-----------------");  
32.        return result;  
33.    }  
34.}  
   
 紧着这我们在配置文件中配置切面、切入点、通知等：
   
  
  
Xml代码  
1.<bean id="aspetbean" class="com.szy.spring.Interceptor"/>  
2.    <aop:config>  
3.        <aop:aspect id="aspet" ref="aspetbean">  
4.            <aop:pointcut id="cut" expression="execution (* com.szy.spring.UserManagerImpl.*(..))"/>  
5.            <aop:before pointcut-ref="cut" method="doBefore"/>  
6.            <aop:after-returning pointcut-ref="cut" method="doAfterReturning"/>  
7.            <aop:after pointcut-ref="cut" method="doAfter"/>  
8.            <aop:after-throwing pointcut-ref="cut" method="doAfterThrowing"/>  
9.            <aop:around pointcut-ref="cut" method="doAround"/>  
10.        </aop:aspect>  
11.    </aop:config>  
   
 运行测试代码输入正常结果。
   
在实际开发中AOP一般用于权限设置等。
   
   
  
  
  
  
Spring学习笔记(17)----使用Spring注解方式管理事务
--------------------------------------------------
使用Spring+JDBC集成步骤如下：
   
 *配置数据源，例如：
   
  
  
Xml代码  
1.<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
2.            <property name="driverClassName" value="com.mysql.jdbc.Driver"/>  
3.            <property name="url" value="jdbc:mysql://localhost:3306/test"/>  
4.            <property name="username" value="root"/>  
5.            <property name="password" value="123456"/>  
6.            <!-- 连接池启动时的初始值 -->  
7.            <property name="initialSize" value="1"/>  
8.            <!-- 连接池的最大值 -->  
9.            <property name="maxActive" value="100"/>  
10.            <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->  
11.            <property name="maxIdle" value="2"/>  
12.            <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->  
13.            <property name="minIdle" value="1"/>  
14.        </bean>  
   
 *配置事务，配置事务时，需要在xml配置文件中引入用于声明事务的tx命名空间，事务的配置有两种方式：注解方式和基于XML配置的方式
   
   
   
下面演示下使用Spring注解方式管理事务
   
首先在配置文件中配置Spring提供的事务管理器
   
  
  
Xml代码  
1.<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
2.            <!-- 指定数据源 -->  
3.            <property name="dataSource" ref="dataSource"/>  
4.        </bean>  
   
 由于会使用注解方式，因此我们要打开注解处理器，对注解进行解析
   
  
  
Xml代码  
1.<tx:annotation-driven transaction-manager="txManager"/>  
   
   
   
这样我们的配置文件配置完成，下面我们在Mysql中建立一张表，
   
  
  
Sql代码  
1.create table users  
2.(                     
3. id int(11) not null auto_increment,    
4. username varchar(20) not null,         
5. primary key (id)                     
6.)   
   
   
   
根据数据库，我们创建javabean
   
  
  
Java代码  
1.package com.szy.spring.bean;  
2./** 
3. * @author  coolszy 
4. * @time    Dec 6, 2009 2:13:33 PM 
5. */  
6.public class User  
7.{  
8.    private int id;  
9.    private String username;  
10.    public int getId()  
11.    {  
12.        return id;  
13.    }  
14.    public void setId(int id)  
15.    {  
16.        this.id = id;  
17.    }  
18.    public String getUsername()  
19.    {  
20.        return username;  
21.    }  
22.    public void setUsername(String username)  
23.    {  
24.        this.username = username;  
25.    }  
26.}     
   
   
   
然后创建DAO接口，在DAO中提供几个方法：
   
  
  
Java代码  
1.package com.szy.spring.dao;  
2.  
3.import java.util.List;  
4.  
5.import com.szy.spring.bean.User;  
6.  
7.public interface UserDAO  
8.{  
9.    public void save(User user);  
10.    public void update(User user);  
11.    Public User  getUser(int id);  
12.    public void delete(int id);  
13.    public List<User> getAllUsers();  
14.}     
   
   
   
实现这个接口
   
   
   
  
  
Java代码  
1.package com.szy.spring.dao.impl;  
2.  
3.import java.util.List;  
4.  
5.import com.szy.spring.bean.User;  
6.import com.szy.spring.service.UserService;  
7.  
8./** 
9. * @author  coolszy 
10. * @time    Dec 6, 2009 2:19:22 PM 
11. */  
12.public class UserDAOImpl implements UserDAO  
13.{  
14.  
15.    public void delete(int id)  
16.    {  
17.  
18.    }  
19.  
20.    public List<User> getAllUsers()  
21.    {  
22.        return null;  
23.    }  
24.  
25.    public User getUser(int id)  
26.    {  
27.  
28.    }  
29.  
30.    public void save(User user)  
31.    {  
32.  
33.    }  
34.  
35.    public void update(User user)  
36.    {  
37.  
38.    }  
39.  
40.}     
   
   
   
下面把这个类交给Spring管理
   
  
  
Xml代码  
1.<bean id="userDAO" class="com.szy.spring.dao.impl.UserDAOImpl"/>    
   
 由于要通过数据源对表进行操作，因此在DAO中添加数据源。
   
  
  
Java代码  
1.private DataSource dataSource;  
2.  
3.    public void setDataSource(DataSource dataSource)  
4.    {  
5.        this.dataSource = dataSource;  
6.    }     
   
   
   
然后在配置文件中进行配置
   
  
  
Xml代码  
1.<bean id="userDAO" class="com.szy.spring.service.impl.UserDAOImpl">  
2.            <property name="dataSource" ref="dataSource"/>  
3.        </bean>     
   
   
   
这样我们就把数据源注入到类中。
   
在UserDAOImpl类中我们提供了dataSource，这样我们就可以对数据库进行操作，但是不推荐直接使用dataSource，建议使用JdbcTemplate
   
  
  
Java代码  
1.private JdbcTemplate jdbcTemplate;  
2.    public void setDataSource(DataSource dataSource)  
3.    {  
4.        //this.dataSource = dataSource;  
5.        this.jdbcTemplate=new JdbcTemplate(dataSource);  
6.    }     
   
 下面我们使用jdbcTemplate对数据库进行增删改查，详细代码见附件。
   
  
  
Java代码  
1.package com.szy.spring.dao.impl;  
2.  
3.import java.util.List;  
4.  
5.import javax.sql.DataSource;  
6.  
7.import org.springframework.jdbc.core.JdbcTemplate;  
8.  
9.import com.szy.spring.bean.User;  
10.import com.szy.spring.dao.UserDAO;  
11.  
12./** 
13. * @author  coolszy 
14. * @time    Dec 6, 2009 2:19:22 PM 
15. */  
16.public class UserDAOImpl implements UserDAO  
17.{  
18.    //private DataSource dataSource;  
19.    private JdbcTemplate jdbcTemplate;  
20.    public void setDataSource(DataSource dataSource)  
21.    {  
22.        //this.dataSource = dataSource;  
23.        this.jdbcTemplate=new JdbcTemplate(dataSource);  
24.    }  
25.  
26.    public void delete(int id)  
27.    {  
28.        jdbcTemplate.update("delete from users where id=?", new Object[]{id},  
29.                new int[]{java.sql.Types.INTEGER});  
30.    }  
31.  
32.    public List<User> getAllUsers()  
33.    {  
34.        return (List<User>)jdbcTemplate.query("select * from users", new UserRowMapper());  
35.    }  
36.  
37.    public User getUser(int id)  
38.    {  
39.        return (User)jdbcTemplate.queryForObject("select * from users where id=?", new Object[]{id},   
40.                new int[]{java.sql.Types.INTEGER}, new UserRowMapper());  
41.  
42.    }  
43.  
44.    public void save(User user)  
45.    {   
46.        jdbcTemplate.update("insert into users(username) values(?)", new Object[]{user.getUsername()},  
47.                new int[]{java.sql.Types.VARCHAR});  
48.  
49.    }  
50.  
51.    public void update(User user)  
52.    {  
53.        jdbcTemplate.update("update users set username=? where id=?", new Object[]{user.getUsername(),user.getId()},  
54.                new int[]{java.sql.Types.VARCHAR, java.sql.Types.INTEGER});  
55.  
56.    }  
57.  
58.}     
   
 编写测试代码，代码运行正常。
   
在我们实现的每个方法中如delete()方法，如果delete方法是这样
   
  
  
Java代码  
1.public void delete(int id)  
2.    {  
3.        jdbcTemplate.update("delete from users where id=?", new Object[]{id},  
4.                new int[]{java.sql.Types.INTEGER});  
5.jdbcTemplate.update("delete from users where id=?", new Object[]{id},  
6.                new int[]{java.sql.Types.INTEGER});  
7.  
8.    }  
9.      
   
 这样每条语句都会在各自的事务中执行，并不能保证在同一使用中执行，为了保证在同一事务中执行，我们应使用Spring容器提供的声明事务，我们在UserDAOImpl 类上加入@Transactional，表示该类受Spring事务管理。如果该类中每个方法不需要事务管理，如getUser方法，则在该方法前加入
   
  
  
Java代码  
1.@Transactional(propagation=Propagation.NOT_SUPPORTED)  
   
   
   
   
   
PS：在上面的配置文件中我们在配置文件中指明了驱动类等信息，如果我们想写在配置文件中要怎么配置能，首先我们编写配置文件，
   
  
  
Jdbc.properties代码  
1.driverClassName=com.mysql.jdbc.Driver  
2.url=jdbc\:mysql\://localhost\:3306/test  
3.username=root  
4.password=123456  
5.initialSize=1  
6.maxActive=100  
7.maxIdle=2  
8.minIdle=1     
   
 然后Spring的配置文件需进行如下配置：
   
  
  
Xml代码  
1.<context:property-placeholder location="classpath:jdbc.properties"/>  
2.        <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
3.            <property name="driverClassName" value="${driverClassName}"/>  
4.            <property name="url" value="${url}"/>  
5.            <property name="username" value="${username}"/>  
6.            <property name="password" value="${password}"/>  
7.            <property name="initialSize" value="${initialSize}"/>  
8.            <property name="maxActive" value="${maxActive}"/>  
9.            <property name="maxIdle" value="${maxIdle}"/>  
10.            <property name="minIdle" value="${minIdle}"/>  
11.        </bean>     
   
  这样就可以从属性文件中读取到配置信息。
   
   
  
  
  
  
  
Spring学习笔记(18)----使用Spring配置文件实现事务管理
-------------------------------------------------------
由于我们要拦截UserDAOImpl中的方法，因此我们需要在配置文件中配置信息，在配置文件中使用了AOP技术来拦截方法。
   
  
  
Xml代码  
1.<aop:config>  
2.    <aop:pointcut id="transactionPointcut" expression="execution(* com.szy.spring.dao.impl..*.*(..))"/>  
3.    <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>  
4.  </aop:config>   
5.  <tx:advice id="txAdvice" transaction-manager="txManager">  
6.     <tx:attributes>  
7.      <!-- 如果连接的方法是以get开头的方法，则不使用事务 -->  
8.       <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>  
9.       <tx:method name="*"/>  
10.     </tx:attributes>  
11.  </tx:advice>  
   
    
   
这样Spring就能对这个类进行事务管理。
   
   
   
下面我们测试下数据库操作是否在同一事务中执行。
   
假设我们的delete方法如下：
   
  
  
Java代码  
1.public void delete(int id)  
2. {  
3.  jdbcTemplate.update("delete from users where id=?", new Object[]{id},  
4.    new int[]{java.sql.Types.INTEGER});  
5.  jdbcTemplate.update("delete from users1 where id=10");  
6. }  
   
   
   
   
   
在第二条删除语句中，users1表是不存在的，如果两次update语句是在两个事务中执行，则第一条能成功执行，并且数据库中该id的记录已经被删除，而第二条由于不存在该表不能正常删除。如果在同一事务中执行，由于第二条update出错，数据库中不能删除任何记录。
   
测试代码：
   
  
  
Java代码  
1.@Test  
2. public void testDelete()  
3. {  
4.  userDAO.delete(5);  
5. }  
   
   
 程序报错，同时id=5的记录没有被删除。如果我们把配置文件中关于事务配置的信息给注释掉，再次测试，程序同样报错，但是id=5的记录被成功删除掉，这说明这两条update语句是在两个不同的事务中运行。
   
   
   
PS：在平时开发中，Spring团队建议使用注解的方式进行配置，这样配置文件显得精简，同时也会做到精确控制。

不错的Spring学习笔记(转)

标签：des   blog   http   io   ar   color   os   使用   sp   

原文地址：http://www.cnblogs.com/sanhuan/p/4152092.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！