spring 测试类test测试方法

web.xml配置文件：

1 <!-- Spring 的监听器可以通过这个上下文参数来获取beans.xml的位置 -->
2     <context-param>
3         <param-name>contextConfigLocation</param-name>
4         <param-value>classpath*:beans.xml</param-value>
5     </context-param>

测试类

 1 package org.konghao.service;
 2 
 3 import javax.inject.Inject;
 4 
 5 import org.hibernate.Session;
 6 import org.hibernate.SessionFactory;
 7 import org.junit.After;
 8 import org.junit.Before;
 9 import org.junit.Test;
10 import org.junit.runner.RunWith;
11 import org.konghao.sys.org.iservice.IInitService;
12 import org.springframework.orm.hibernate4.SessionHolder;
13 import org.springframework.test.context.ContextConfiguration;
14 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
15 import org.springframework.transaction.support.TransactionSynchronizationManager;
16 
17 @RunWith(SpringJUnit4ClassRunner.class)
18 @ContextConfiguration("/beans.xml")
19 public class TestInitService {
20     @Inject
21     private IInitService initService;
22     @Inject
23     private SessionFactory sessionFactory;
24     
25     @Before
26     public void setUp() {
27         //此时最好不要使用Spring的Transactional来管理，因为dbunit是通过jdbc来处理connection，再使用spring在一些编辑操作中会造成事务shisu
28         Session s = sessionFactory.openSession();
29         TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(s));
30         //SystemContext.setRealPath("D:\teach_source\class2\j2EE\dingan\cms-da\src\main\webapp");
31     }
32     
33     @After
34     public void tearDown() {
35         SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
36         Session s = holder.getSession(); 
37         s.flush();
38         TransactionSynchronizationManager.unbindResource(sessionFactory);
39     }
40     @Test
41     public void testInitByXml() {
42         initService.initEntityByXml("orgs.xml");
43     }
44 }

解析xml文件将信息保存到数据库;

 1 package org.konghao.sys.org.service.impl;
 2 
 3 import java.lang.reflect.InvocationTargetException;
 4 import java.lang.reflect.Method;
 5 import java.util.List;
 6 
 7 import javax.inject.Inject;
 8 
 9 import org.apache.commons.beanutils.BeanUtils;
10 import org.dom4j.Attribute;
11 import org.dom4j.Document;
12 import org.dom4j.DocumentException;
13 import org.dom4j.Element;
14 import org.dom4j.io.SAXReader;
15 import org.konghao.sys.org.iservice.IInitService;
16 import org.konghao.sys.org.model.SysException;
17 import org.springframework.beans.factory.BeanFactory;
18 import org.springframework.stereotype.Service;
19 
20 @Service("initService")
21 public class InitService extends AbstractBaseSevice implements IInitService{
22     
23     private Document document;
24     @Inject
25     private BeanFactory factory;
26 
27     @Override
28     public void initEntityByXml(String filename) {
29         Element root = this.readDocument(filename);
30         String pname = root.attributeValue("package");
31         List<Element> initEntitys = root.selectNodes("/entitys/initEntity");
32         for (Element element : initEntitys) {
33             //如果这个实体存在就不添加
34             if (element.attributeValue("exist") == "1") {
35                 continue;
36             }else{
37                 String cname = element.attributeValue("class");
38                 cname = pname + "." + cname;
39                 String method = element.attributeValue("method");
40                 List<Element> entitys = (List<Element>)element.selectNodes("entity");
41                 addElements(cname,method,entitys);
42             }
43         }
44     }
45     
46     private Element readDocument(String filename){
47         try {
48             SAXReader saxReader = new SAXReader();
49             Document d = saxReader.read( InitService.class.getClassLoader().getResourceAsStream("init/" + filename));
50             return d.getRootElement();
51         } catch (DocumentException e) {
52             e.printStackTrace();
53         }
54         return null;
55         
56     }
57     
58     private void addElements(String cname, String method, List<Element> entitys) {
59         for (Element element : entitys) {
60             addElement(cname , method , element);
61         }
62     }
63 
64     private void addElement(String cname, String method, Element element) {
65         List<Attribute> attrs = element.attributes();
66         try {
67             Object o = Class.forName(cname).newInstance();
68             String[] methods = method.split("\.");
69             if (methods.length !=2) {
70                 throw new SysException("方法格式不正确");
71             }
72             String sname = methods[0]; //对应org.xml文件的method的第一个
73             String mname = methods[1];
74             for (Attribute attribute : attrs) {
75                 System.out.println(attribute.getName() + " ; " + attribute.getValue());
76                 String name = attribute.getName();
77                 String value = attribute.getValue();
78                 BeanUtils.copyProperty(o, name, value);//利用反射进行拷贝
79             }
80             Object service = factory.getBean(sname);//该sname应该与注入的service名称一致 ，例如本地中使用的是OrgtypeService，则对应的service也是OrgTypeService，否则将报找不到该注入的类型
81             Method m = service.getClass().getMethod(mname , o.getClass());
82             m.invoke(service, o);
83         } catch (ClassNotFoundException e) {
84             e.printStackTrace();
85         } catch (IllegalAccessException e) {
86             e.printStackTrace();
87         } catch (InvocationTargetException e) {
88             e.printStackTrace();
89         } catch (SecurityException e) {
90             e.printStackTrace();
91         } catch (NoSuchMethodException e) {
92             e.printStackTrace();
93         } catch (InstantiationException e) {
94             e.printStackTrace();
95         }
96     }
97 
98 
99

解析文件：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <entitys package="org.konghao.sys.org.model" >
 3     <initEntity exist="1" class="OrgType" method="OrgTypeService.add">
 4         <entity name="学校" sn="XX" />
 5         <entity name="分校" sn="FX" />
 6         <entity name="校办领导" sn="XBLD" />
 7         <entity name="行政部门" sn="XZBM" />
 8         <entity name="教学部门" sn="JXBM" />
 9         <entity name="专业" sn="ZY" />
10         <entity name="班级" sn="    BJ" />
11     </initEntity>
12     
13     <initEntity exist="0" class="Position" method="PositionService.add">
14         <entity name="校长" sn="XZ" />
15         <entity name="副校长" sn="FXZ" />
16         <entity name="处长" sn="CZ" />
17         <entity name="副处长" sn="FCZ" />
18         <entity name="科长" sn="KZ" />
19         <entity name="辅导员" sn="RDY" />
20         <entity name="班主任" sn="BZR" />
21     </initEntity>
22 </entitys>

底层实现：

 1 package org.konghao.sys.org.service.impl;
 2 
 3 import java.util.List;
 4 
 5 import javax.inject.Inject;
 6 
 7 import org.konghao.sys.org.idao.IOrgTypeDao;
 8 import org.konghao.sys.org.iservice.IOrgTypeService;
 9 import org.konghao.sys.org.model.OrgType;
10 import org.konghao.sys.org.model.SysException;
11 import org.springframework.stereotype.Service;
12 
13 @Service("OrgTypeService")
14 public class OrgTypeService extends AbstractBaseSevice implements IOrgTypeService{
15     
16     @Inject
17     private IOrgTypeDao orgTypeDao;
18 
19     @Override
20     public void add(OrgType orgType) {
21         if (orgTypeDao.loadBySn(orgType.getSn()) != null) {
22             throw new SysException("要添加的组织机构类型的sn已经存在");
23         }
24         orgTypeDao.add(orgType);
25     }
26 
27     
28 }

spring的beans.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" xmlns:aop="http://www.springframework.org/schema/aop"
  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
  7          http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  8          http://www.springframework.org/schema/context
  9          http://www.springframework.org/schema/context/spring-context-3.0.xsd
 10          http://www.springframework.org/schema/aop
 11          http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
 12          http://www.springframework.org/schema/tx 
 13          http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
 14     <!-- 打开Spring的Annotation支持 -->
 15     <context:annotation-config />
 16     <!-- 设定Spring 去哪些包中找Annotation -->
 17     <context:component-scan base-package="org.konghao" />
 18     
 19     <bean id="ftlPath" class="java.lang.String">
 20         <constructor-arg value="/ftl"/>
 21     </bean>
 22     
 23     <bean id="outPath" class="java.lang.String">
 24         <constructor-arg value="/jsp/template"/>
 25     </bean>
 26 
 27     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
 28         destroy-method="close">
 29         <property name="driverClassName" value="${jdbc.driverClassName}" />
 30         <property name="url" value="${jdbc.url}" />
 31         <property name="username" value="${jdbc.username}" />
 32         <property name="password" value="${jdbc.password}" />
 33         <!-- 配置连接池的初始值 -->
 34         <property name="initialSize" value="1" />
 35         <!-- 连接池的最大值 -->
 36         <!-- <property name="maxActive" value="500"/> -->
 37         <!-- 最大空闲时，当经过一个高峰之后，连接池可以将一些用不到的连接释放，一直减少到maxIdle为止 -->
 38         <!-- <property name="maxIdle" value="2"/> -->
 39         <!-- 当最小空闲时，当连接少于minIdle时会自动去申请一些连接 -->
 40         <property name="minIdle" value="1" />
 41         <property name="maxActive" value="100" />
 42         <property name="maxIdle" value="20" />
 43         <property name="maxWait" value="1000" />
 44     </bean>
 45     <!--创建Spring的SessionFactory工厂 -->
 46     <context:property-placeholder location="classpath:jdbc.properties" />
 47     <!-- 
 48     和hibernate4整合没有提供专门的针对Annotation的类，直接在LocalSessionFactoryBean中已经集成
 49  -->
 50     <bean id="sessionFactory"
 51         class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
 52         <!-- 注入数据源 -->
 53         <property name="dataSource" ref="dataSource" />
 54         <!-- 设置Spring取那个包中查找相应的实体类 -->
 55         <property name="packagesToScan">
 56             <value>org.konghao.sys.org.model</value>
 57         </property>
 58         <property name="hibernateProperties">
 59             <!-- <value> hibernate.dialect=org.hibernate.dialect.HSQLDialect </value> -->
 60             <props>
 61                 <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
 62                 <prop key="hibernate.show_sql">true</prop>
 63                 <prop key="hibernate.hbm2ddl.auto">update</prop>
 64                 <prop key="hibernate.format_sql">true</prop>
 65             </props>
 66         </property>
 67     </bean>
 68 
 69     <!-- 配置Spring的事务处理 -->
 70     <!-- 创建事务管理器-->
 71     <bean id="txManager"
 72         class="org.springframework.orm.hibernate4.HibernateTransactionManager">
 73         <property name="sessionFactory" ref="sessionFactory" />
 74     </bean>
 75 <!-- 配置AOP，Spring是通过AOP来进行事务管理的 -->
 76     <aop:config>
 77     <!-- 设置pointCut表示哪些方法要加入事务处理 -->
 78     <!-- 以下的事务是声明在DAO中，但是通常都会在Service来处理多个业务对象逻辑的关系，注入删除，更新等，此时如果在执行了一个步骤之后抛出异常
 79         就会导致数据不完整，所以事务不应该在DAO层处理，而应该在service，这也就是Spring所提供的一个非常方便的工具，声明式事务 -->
 80         <aop:pointcut id="allMethods"
 81             expression="execution(* org.konghao.sys.org.service.impl.*.*(..))" />
 82         <!-- 通过advisor来确定具体要加入事务控制的方法 -->
 83         <aop:advisor advice-ref="txAdvice" pointcut-ref="allMethods" />
 84     </aop:config>
 85 <!-- 配置哪些方法要加入事务控制 -->
 86     <tx:advice id="txAdvice" transaction-manager="txManager">
 87         <tx:attributes>
 88         <!-- 让所有的方法都加入事务管理，为了提高效率，可以把一些查询之类的方法设置为只读的事务 -->
 89             <tx:method name="*" propagation="REQUIRED" read-only="true"/>
 90             <!-- 以下方法都是可能设计修改的方法，就无法设置为只读 -->
 91             <tx:method name="add*" propagation="REQUIRED"/>
 92             <tx:method name="del*" propagation="REQUIRED"/>
 93             <tx:method name="update*" propagation="REQUIRED"/>
 94             <tx:method name="save*" propagation="REQUIRED"/>
 95             <tx:method name="clear*" propagation="REQUIRED"/>
 96             <tx:method name="empty*" propagation="REQUIRED"/>
 97             <tx:method name="init*" propagation="REQUIRED"/>
 98         </tx:attributes>
 99     </tx:advice>
100 </beans>

————————————————————————————————————————————————————————————————————————

版本3：多层次解析xml文件的实现

  1 package org.konghao.sys.org.service.impl;
  2 
  3 import java.lang.reflect.InvocationTargetException;
  4 import java.lang.reflect.Method;
  5 import java.util.Iterator;
  6 import java.util.List;
  7 
  8 import javax.inject.Inject;
  9 import javax.persistence.criteria.CriteriaBuilder.In;
 10 
 11 import org.apache.commons.beanutils.BeanUtils;
 12 import org.dom4j.Attribute;
 13 import org.dom4j.Document;
 14 import org.dom4j.DocumentException;
 15 import org.dom4j.Element;
 16 import org.dom4j.io.SAXReader;
 17 import org.konghao.sys.org.iservice.IInitService;
 18 import org.konghao.sys.org.model.OrgType;
 19 import org.konghao.sys.org.model.SysException;
 20 import org.springframework.beans.factory.BeanFactory;
 21 import org.springframework.stereotype.Service;
 22 
 23 @Service("initService")
 24 public class InitService extends AbstractBaseSevice implements IInitService{
 25     
 26     private Document document;
 27     @Inject
 28     private BeanFactory factory;
 29 
 30     @Override
 31     public void initEntityByXml(String filename) {
 32         Element root = this.readDocument(filename);
 33         String pname = root.attributeValue("package");
 34         List<Element> initEntitys = root.selectNodes("/entitys/initEntity");
 35         for (Element element : initEntitys) {
 36             String ipname = element.attributeValue("package");
 37             String cname = element.attributeValue("class");
 38             System.out.println(element.attributeValue("exist"));
 39             //如果为1 表示已经添加过了
 40             if (element.attributeValue("exist") == "1" || element.attributeValue("exist").equals("1")) {
 41                 continue;
 42             }if (ipname != null && !"".equals(ipname)) {
 43                 cname = ipname + "." + cname;
 44             } else{
 45                 cname = pname + "." + cname;
 46             }
 47             String method = element.attributeValue("method");
 48             List<Element> entitys = (List<Element>)element.selectNodes("entity");
 49             System.out.println(cname + "  " + method );
 50             addElements(cname,method,entitys); 
 51             
 52         }
 53     }
 54     
 55     private Element readDocument(String filename){
 56         try {
 57             SAXReader saxReader = new SAXReader();
 58             Document d = saxReader.read( InitService.class.getClassLoader().getResourceAsStream("init/" + filename));
 59             return d.getRootElement();
 60         } catch (DocumentException e) {
 61             e.printStackTrace();
 62         }
 63         return null;
 64         
 65     }
 66     
 67     private void addElements(String cname, String method, List<Element> entitys) {
 68         for (Element element : entitys) {
 69             addElement(cname , method , element , null);
 70         }
 71     }
 72 
 73     private void addElement(String cname, String method, Element e,Object parent) {
 74         try {
 75             //获取所有的属性
 76             List<Attribute> atts = (List<Attribute>)e.attributes();
 77             Object obj = Class.forName(cname).newInstance();
 78             String [] ms = method.split("\.");
 79             if(ms.length!=2) throw new SysException("方法格式不正确");
 80             String sname = ms[0]; String mname = ms[1];
 81             for(Attribute att:atts) {
 82                 String name = att.getName();
 83                 String value = att.getValue();
 84                 BeanUtils.copyProperty(obj, name, value);
 85             }
 86             if(parent!=null) {
 87                 BeanUtils.copyProperty(obj, "parent", parent);
 88             }
 89             Object service = factory.getBean(sname);
 90             Method m = service.getClass().getMethod(mname,obj.getClass());
 91             m.invoke(service, obj);
 92             List<Element> es = e.selectNodes("entity");
 93             for(Element ele:es) {
 94                 addElement(cname, method, ele, obj);
 95             }
 96         } catch (ClassNotFoundException e1) {
 97             e1.printStackTrace();
 98         } catch (IllegalAccessException e1) {
 99             e1.printStackTrace();
100         } catch (InvocationTargetException e1) {
101             e1.printStackTrace();
102         } catch (SecurityException e1) {
103             e1.printStackTrace();
104         } catch (NoSuchMethodException e1) {
105             e1.printStackTrace();
106         } catch (InstantiationException e1) {
107             e1.printStackTrace();
108         }
109     }
110 
111 }

实体类Org

  1 package org.konghao.sys.org.model;
  2 
  3 import java.util.List;
  4 
  5 import javax.persistence.Column;
  6 import javax.persistence.Entity;
  7 import javax.persistence.GeneratedValue;
  8 import javax.persistence.Id;
  9 import javax.persistence.JoinColumn;
 10 import javax.persistence.ManyToOne;
 11 import javax.persistence.Table;
 12 
 13 /**
 14  * 组织对象，该表可以生成完整的组织树
 15  * 根据组织类型来具体存储实际中存在的组织
 16  * 学院  --> xx
 17  * 校本部--> FX
 18  * 南校区--> FX
 19  * @author jrx
 20  *
 21  */
 22 @Entity
 23 @Table(name="t_org")
 24 public class Org {
 25     
 26     /**
 27      *  组织机构的id
 28      */
 29     private int id;
 30     /**
 31      * 组织机构的名称
 32      */
 33     private String name ; 
 34     /**
 35      * 组织机构所属类型的id，此处不要使用ManyToOne
 36      */
 37     private Integer typeId;
 38     /**
 39      * 组织机构所属类型的名称，冗余
 40      */
 41     private String typeName;
 42     /**
 43      * 组织机构的排序号
 44      */
 45     private Integer orderNum ; 
 46     /**
 47      * 组织机构的父亲组织
 48      */
 49     private Org parent ; 
 50     /**
 51      * 管理类型
 52      */
 53     private int managerType;
 54     /**
 55      * 组织机构的地址
 56      */
 57     private String address ; 
 58     /**
 59      * 组织机构的电话
 60      */
 61     private String phone ; 
 62     /**
 63      * 扩展属性，用于在针对某些特殊的组织存储相应的信息
 64      */
 65     private String att1 ; 
 66     private String att2 ; 
 67     private String att3 ;
 68     
 69     @Id
 70     @GeneratedValue
 71     public int getId() {
 72         return id;
 73     }
 74 
 75     public void setId(int id) {
 76         this.id = id;
 77     }
 78 
 79     public String getName() {
 80         return name;
 81     }
 82 
 83     public void setName(String name) {
 84         this.name = name;
 85     }
 86 
 87     @Column(name="tid")
 88     public Integer getTypeId() {
 89         return typeId;
 90     }
 91 
 92     public void setTypeId(Integer typeId) {
 93         this.typeId = typeId;
 94     }
 95     @Column(name="tname")
 96     public String getTypeName() {
 97         return typeName;
 98     }
 99 
100     public void setTypeName(String typeName) {
101         this.typeName = typeName;
102     }
103     @Column(name="order_num")
104     public Integer getOrderNum() {
105         return orderNum;
106     }
107 
108     public void setOrderNum(Integer orderNum) {
109         this.orderNum = orderNum;
110     }
111     @ManyToOne
112     @JoinColumn(name="pid")
113     public Org getParent() {
114         return parent;
115     }
116 
117     public void setParent(Org parent) {
118         this.parent = parent;
119     }
120 
121     public String getAddress() {
122         return address;
123     }
124 
125     public void setAddress(String address) {
126         this.address = address;
127     }
128 
129     public String getPhone() {
130         return phone;
131     }
132 
133     public void setPhone(String phone) {
134         this.phone = phone;
135     }
136 
137     public String getAtt1() {
138         return att1;
139     }
140 
141     public void setAtt1(String att1) {
142         this.att1 = att1;
143     }
144 
145     public String getAtt2() {
146         return att2;
147     }
148 
149     public void setAtt2(String att2) {
150         this.att2 = att2;
151     }
152 
153     public String getAtt3() {
154         return att3;
155     }
156 
157     public void setAtt3(String att3) {
158         this.att3 = att3;
159     }
160 
161     @Column(name = "manager_type")
162     public int getManagerType() {
163         return managerType;
164     }
165 
166     public void setManagerType(int managerType) {
167         this.managerType = managerType;
168     }
169 
170     @Override
171     public String toString() {
172         return "Org [id=" + id + ", name=" + name + ", typeId=" + typeId
173                 + ", typeName=" + typeName + ", orderNum=" + orderNum
174                 + ", parent=" + parent + ", managerType=" + managerType
175                 + ", address=" + address + ", phone=" + phone + ", att1="
176                 + att1 + ", att2=" + att2 + ", att3=" + att3 + "]";
177     }
178 
179     
180 }

底层实现：

 1 package org.konghao.sys.org.service.impl;
 2 
 3 import java.util.List;
 4 
 5 import javax.inject.Inject;
 6 
 7 import org.konghao.basic.model.Pager;
 8 import org.konghao.sys.dto.TreeDto;
 9 import org.konghao.sys.org.idao.IOrgDao;
10 import org.konghao.sys.org.idao.IOrgTypeDao;
11 import org.konghao.sys.org.iservice.IOrgService;
12 import org.konghao.sys.org.model.Org;
13 import org.konghao.sys.org.model.SysException;
14 import org.springframework.stereotype.Service;
15 
16 @Service("orgService")
17 public class OrgService extends AbstractBaseSevice implements IOrgService {
18 
19     
20     @Inject
21     private IOrgDao orgDao;
22     
23     @Inject
24     private IOrgTypeDao orgTypeDao;
25     
26     private void checkChildOrgNum(Org cOrg , Org pOrg){
27         if (pOrg == null) {
28             return;
29         }
30         //获取根据组织类型获取某组织类型下组织的数量（数量根据OrgTypeRule的num来确定数量，即某类型下组织数量需小于等于OrgTypeRule中num的数量）
31         int hnum = orgDao.loadNumByType(pOrg.getId(), cOrg.getTypeId());
32         //根据组织类型的父id和子id获取num数量
33         int rnum = orgTypeDao.loadOrgTypeRuleNum(pOrg.getTypeId(), cOrg.getTypeId());
34         if (rnum < 0) {
35             return;
36         }
37         if (hnum >= rnum) {
38             throw new SysException(pOrg.getName() +"下的" + cOrg.getName() + "的数量已经达到最大化");
39         }
40     }
41     
42     //parent已经存在的添加
43     @Override
44     public void add(Org org) {
45         checkChildOrgNum(org, org.getParent());
46         if (org.getParent() != null) {
47             org.setOrderNum(orgDao.getMaxOrder(org.getParent().getId()));
48         }else {
49             org.setOrderNum(null);
50         }
51         orgDao.add(org);
52     }
53 
54     @Override
55     public void add(Org org, Integer pid) {
56         if (pid != null) {
57             Org p = orgDao.load(pid);
58             if (p == null) {
59                 throw new SysException("要添加的父组织不存在");
60             }
61             checkChildOrgNum(org, org.getParent());
62             org.setParent(p);
63         }
64         org.setOrderNum(orgDao.getMaxOrder(pid));
65         orgDao.add(org);
66     }
67 
68 }

相关阅读:
Python操作Excel表格
 Python爬虫实战：爬取美食节川菜信息
 超级实用的Python网络爬虫反反爬策略之构造UA池及IP代理池
 Python 静态方法
 IDEA连接远程服务器Docker部署Spring Boot项目
 Dockerfile 解析
 Python爬虫实战-统计博客园阅读量问题
 Docker 容器数据卷
 Docker镜像
 PL/SQL
原文地址：https://www.cnblogs.com/a757956132/p/6072962.html