spring 测试类test测试方法

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

package org.konghao.service; import javax.inject.Inject; import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.konghao.sys.org.iservice.IInitService;
import org.springframework.orm.hibernate4.SessionHolder;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.support.TransactionSynchronizationManager; @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/beans.xml")
public class TestInitService {
@Inject
private IInitService initService;
@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 }
@Test
public void testInitByXml() {
initService.initEntityByXml("orgs.xml");
}
}

package org.konghao.sys.org.service.impl; import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.List; import javax.inject.Inject; import org.apache.commons.beanutils.BeanUtils;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.konghao.sys.org.iservice.IInitService;
import org.konghao.sys.org.model.SysException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.stereotype.Service; @Service("initService")
public class InitService extends AbstractBaseSevice implements IInitService{ private Document document;
@Inject
private BeanFactory factory; @Override
public void initEntityByXml(String filename) {
Element root = this.readDocument(filename);
String pname = root.attributeValue("package");
List<Element> initEntitys = root.selectNodes("/entitys/initEntity");
for (Element element : initEntitys) {
//如果这个实体存在就不添加
if (element.attributeValue("exist") == "1") {
continue;
}else{
String cname = element.attributeValue("class");
cname = pname + "." + cname;
String method = element.attributeValue("method");
List<Element> entitys = (List<Element>)element.selectNodes("entity");
addElements(cname,method,entitys);
}
}
} private Element readDocument(String filename){
try {
SAXReader saxReader = new SAXReader();
Document d = saxReader.read( InitService.class.getClassLoader().getResourceAsStream("init/" + filename));
return d.getRootElement();
} catch (DocumentException e) {
e.printStackTrace();
}
return null; } private void addElements(String cname, String method, List<Element> entitys) {
for (Element element : entitys) {
addElement(cname , method , element);
}
} private void addElement(String cname, String method, Element element) {
List<Attribute> attrs = element.attributes();
try {
Object o = Class.forName(cname).newInstance();
String[] methods = method.split("\\.");
if (methods.length !=2) {
throw new SysException("方法格式不正确");
}
String sname = methods[0]; //对应org.xml文件的method的第一个
String mname = methods[1];
for (Attribute attribute : attrs) {
System.out.println(attribute.getName() + " ; " + attribute.getValue());
String name = attribute.getName();
String value = attribute.getValue();
BeanUtils.copyProperty(o, name, value);//利用反射进行拷贝
}
Object service = factory.getBean(sname);//该sname应该与注入的service名称一致 ，例如本地中使用的是OrgtypeService，则对应的service也是OrgTypeService，否则将报找不到该注入的类型
Method m = service.getClass().getMethod(mname , o.getClass());
m.invoke(service, o);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
}

<?xml version="1.0" encoding="UTF-8"?>
<entitys package="org.konghao.sys.org.model" >
<initEntity exist="1" class="OrgType" method="OrgTypeService.add">
<entity name="学校" sn="XX" />
<entity name="分校" sn="FX" />
<entity name="校办领导" sn="XBLD" />
<entity name="行政部门" sn="XZBM" />
<entity name="教学部门" sn="JXBM" />
<entity name="专业" sn="ZY" />
<entity name="班级" sn=" BJ" />
</initEntity> <initEntity exist="0" class="Position" method="PositionService.add">
<entity name="校长" sn="XZ" />
<entity name="副校长" sn="FXZ" />
<entity name="处长" sn="CZ" />
<entity name="副处长" sn="FCZ" />
<entity name="科长" sn="KZ" />
<entity name="辅导员" sn="RDY" />
<entity name="班主任" sn="BZR" />
</initEntity>
</entitys>

package org.konghao.sys.org.service.impl; import java.util.List; import javax.inject.Inject; import org.konghao.sys.org.idao.IOrgTypeDao;
import org.konghao.sys.org.iservice.IOrgTypeService;
import org.konghao.sys.org.model.OrgType;
import org.konghao.sys.org.model.SysException;
import org.springframework.stereotype.Service; @Service("OrgTypeService")
public class OrgTypeService extends AbstractBaseSevice implements IOrgTypeService{ @Inject
private IOrgTypeDao orgTypeDao; @Override
public void add(OrgType orgType) {
if (orgTypeDao.loadBySn(orgType.getSn()) != null) {
throw new SysException("要添加的组织机构类型的sn已经存在");
}
orgTypeDao.add(orgType);
} }

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
<!-- 打开Spring的Annotation支持 -->
<context:annotation-config />
<!-- 设定Spring 去哪些包中找Annotation -->
<context:component-scan base-package="org.konghao" /> <bean id="ftlPath" class="java.lang.String">
<constructor-arg value="/ftl"/>
</bean> <bean id="outPath" class="java.lang.String">
<constructor-arg value="/jsp/template"/>
</bean> <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
<!-- 配置连接池的初始值 -->
<property name="initialSize" value="1" />
<!-- 连接池的最大值 -->
<!-- <property name="maxActive" value="500"/> -->
<!-- 最大空闲时，当经过一个高峰之后，连接池可以将一些用不到的连接释放，一直减少到maxIdle为止 -->
<!-- <property name="maxIdle" value="2"/> -->
<!-- 当最小空闲时，当连接少于minIdle时会自动去申请一些连接 -->
<property name="minIdle" value="1" />
<property name="maxActive" value="100" />
<property name="maxIdle" value="20" />
<property name="maxWait" value="1000" />
</bean>
<!--创建Spring的SessionFactory工厂 -->
<context:property-placeholder location="classpath:jdbc.properties" />
<!--
和hibernate4整合没有提供专门的针对Annotation的类，直接在LocalSessionFactoryBean中已经集成
-->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<!-- 注入数据源 -->
<property name="dataSource" ref="dataSource" />
<!-- 设置Spring取那个包中查找相应的实体类 -->
<property name="packagesToScan">
<value>org.konghao.sys.org.model</value>
</property>
<property name="hibernateProperties">
<!-- <value> hibernate.dialect=org.hibernate.dialect.HSQLDialect </value> -->
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
<prop key="hibernate.format_sql">true</prop>
</props>
</property>
</bean> <!-- 配置Spring的事务处理 -->
<!-- 创建事务管理器-->
<bean id="txManager"
class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- 配置AOP，Spring是通过AOP来进行事务管理的 -->
<aop:config>
<!-- 设置pointCut表示哪些方法要加入事务处理 -->
<!-- 以下的事务是声明在DAO中，但是通常都会在Service来处理多个业务对象逻辑的关系，注入删除，更新等，此时如果在执行了一个步骤之后抛出异常
就会导致数据不完整，所以事务不应该在DAO层处理，而应该在service，这也就是Spring所提供的一个非常方便的工具，声明式事务 -->
<aop:pointcut id="allMethods"
expression="execution(* org.konghao.sys.org.service.impl.*.*(..))" />
<!-- 通过advisor来确定具体要加入事务控制的方法 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="allMethods" />
</aop:config>
<!-- 配置哪些方法要加入事务控制 -->
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<!-- 让所有的方法都加入事务管理，为了提高效率，可以把一些查询之类的方法设置为只读的事务 -->
<tx:method name="*" propagation="REQUIRED" read-only="true"/>
<!-- 以下方法都是可能设计修改的方法，就无法设置为只读 -->
<tx:method name="add*" propagation="REQUIRED"/>
<tx:method name="del*" propagation="REQUIRED"/>
<tx:method name="update*" propagation="REQUIRED"/>
<tx:method name="save*" propagation="REQUIRED"/>
<tx:method name="clear*" propagation="REQUIRED"/>
<tx:method name="empty*" propagation="REQUIRED"/>
<tx:method name="init*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
</beans>

package org.konghao.sys.org.service.impl; import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Iterator;
import java.util.List; import javax.inject.Inject;
import javax.persistence.criteria.CriteriaBuilder.In; import org.apache.commons.beanutils.BeanUtils;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.konghao.sys.org.iservice.IInitService;
import org.konghao.sys.org.model.OrgType;
import org.konghao.sys.org.model.SysException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.stereotype.Service; @Service("initService")
public class InitService extends AbstractBaseSevice implements IInitService{ private Document document;
@Inject
private BeanFactory factory; @Override
public void initEntityByXml(String filename) {
Element root = this.readDocument(filename);
String pname = root.attributeValue("package");
List<Element> initEntitys = root.selectNodes("/entitys/initEntity");
for (Element element : initEntitys) {
String ipname = element.attributeValue("package");
String cname = element.attributeValue("class");
System.out.println(element.attributeValue("exist"));
//如果为1 表示已经添加过了
if (element.attributeValue("exist") == "1" || element.attributeValue("exist").equals("1")) {
continue;
}if (ipname != null && !"".equals(ipname)) {
cname = ipname + "." + cname;
} else{
cname = pname + "." + cname;
}
String method = element.attributeValue("method");
List<Element> entitys = (List<Element>)element.selectNodes("entity");
System.out.println(cname + " " + method );
addElements(cname,method,entitys); }
} private Element readDocument(String filename){
try {
SAXReader saxReader = new SAXReader();
Document d = saxReader.read( InitService.class.getClassLoader().getResourceAsStream("init/" + filename));
return d.getRootElement();
} catch (DocumentException e) {
e.printStackTrace();
}
return null; } private void addElements(String cname, String method, List<Element> entitys) {
for (Element element : entitys) {
addElement(cname , method , element , null);
}
} private void addElement(String cname, String method, Element e,Object parent) {
try {
//获取所有的属性
List<Attribute> atts = (List<Attribute>)e.attributes();
Object obj = Class.forName(cname).newInstance();
String [] ms = method.split("\\.");
if(ms.length!=2) throw new SysException("方法格式不正确");
String sname = ms[0]; String mname = ms[1];
for(Attribute att:atts) {
String name = att.getName();
String value = att.getValue();
BeanUtils.copyProperty(obj, name, value);
}
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 }
} catch (ClassNotFoundException e1) {
e1.printStackTrace();
} catch (IllegalAccessException e1) {
e1.printStackTrace();
} catch (InvocationTargetException e1) {
e1.printStackTrace();
} catch (SecurityException e1) {
e1.printStackTrace();
} catch (NoSuchMethodException e1) {
e1.printStackTrace();
} catch (InstantiationException e1) {
e1.printStackTrace();
}
} }

package org.konghao.sys.org.model; import java.util.List; import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table; /**
* 组织对象，该表可以生成完整的组织树
* 根据组织类型来具体存储实际中存在的组织
* 学院 --> xx
* 校本部--> FX
* 南校区--> FX
* @author jrx
*
*/
@Entity
@Table(name="t_org")
public class Org { /**
* 组织机构的id
*/
private int id;
/**
* 组织机构的名称
*/
private String name ;
/**
* 组织机构所属类型的id，此处不要使用ManyToOne
*/
private Integer typeId;
/**
* 组织机构所属类型的名称，冗余
*/
private String typeName;
/**
* 组织机构的排序号
*/
private Integer orderNum ;
/**
* 组织机构的父亲组织
*/
private Org parent ;
/**
* 管理类型
*/
private int managerType;
/**
* 组织机构的地址
*/
private String address ;
/**
* 组织机构的电话
*/
private String phone ;
/**
* 扩展属性，用于在针对某些特殊的组织存储相应的信息
*/
private String att1 ;
private String att2 ;
private String att3 ; @Id
@GeneratedValue
public int getId() {
return id;
} public void setId(int id) {
this.id = id;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} @Column(name="tid")
public Integer getTypeId() {
return typeId;
} public void setTypeId(Integer typeId) {
this.typeId = typeId;
}
@Column(name="tname")
public String getTypeName() {
return typeName;
} public void setTypeName(String typeName) {
this.typeName = typeName;
}
@Column(name="order_num")
public Integer getOrderNum() {
return orderNum;
} public void setOrderNum(Integer orderNum) {
this.orderNum = orderNum;
}
@ManyToOne
@JoinColumn(name="pid")
public Org getParent() {
return parent;
} public void setParent(Org parent) {
this.parent = parent;
} public String getAddress() {
return address;
} public void setAddress(String address) {
this.address = address;
} public String getPhone() {
return phone;
} public void setPhone(String phone) {
this.phone = phone;
} public String getAtt1() {
return att1;
} public void setAtt1(String att1) {
this.att1 = att1;
} public String getAtt2() {
return att2;
} public void setAtt2(String att2) {
this.att2 = att2;
} public String getAtt3() {
return att3;
} public void setAtt3(String att3) {
this.att3 = att3;
} @Column(name = "manager_type")
public int getManagerType() {
return managerType;
} public void setManagerType(int managerType) {
this.managerType = managerType;
} @Override
public String toString() {
return "Org [id=" + id + ", name=" + name + ", typeId=" + typeId
+ ", typeName=" + typeName + ", orderNum=" + orderNum
+ ", parent=" + parent + ", managerType=" + managerType
+ ", address=" + address + ", phone=" + phone + ", att1="
+ att1 + ", att2=" + att2 + ", att3=" + att3 + "]";
} }

package org.konghao.sys.org.service.impl; import java.util.List; import javax.inject.Inject; import org.konghao.basic.model.Pager;
import org.konghao.sys.dto.TreeDto;
import org.konghao.sys.org.idao.IOrgDao;
import org.konghao.sys.org.idao.IOrgTypeDao;
import org.konghao.sys.org.iservice.IOrgService;
import org.konghao.sys.org.model.Org;
import org.konghao.sys.org.model.SysException;
import org.springframework.stereotype.Service; @Service("orgService")
public class OrgService extends AbstractBaseSevice implements IOrgService { @Inject
private IOrgDao orgDao; @Inject
private IOrgTypeDao orgTypeDao; private void checkChildOrgNum(Org cOrg , Org pOrg){
if (pOrg == null) {
return;
}
//获取根据组织类型获取某组织类型下组织的数量（数量根据OrgTypeRule的num来确定数量，即某类型下组织数量需小于等于OrgTypeRule中num的数量）
int hnum = orgDao.loadNumByType(pOrg.getId(), cOrg.getTypeId());
//根据组织类型的父id和子id获取num数量
int rnum = orgTypeDao.loadOrgTypeRuleNum(pOrg.getTypeId(), cOrg.getTypeId());
if (rnum < 0) {
return;
}
if (hnum >= rnum) {
throw new SysException(pOrg.getName() +"下的" + cOrg.getName() + "的数量已经达到最大化");
}
} //parent已经存在的添加
@Override
public void add(Org org) {
checkChildOrgNum(org, org.getParent());
if (org.getParent() != null) {
org.setOrderNum(orgDao.getMaxOrder(org.getParent().getId()));
}else {
org.setOrderNum(null);
}
orgDao.add(org);
} @Override
public void add(Org org, Integer pid) {
if (pid != null) {
Org p = orgDao.load(pid);
if (p == null) {
throw new SysException("要添加的父组织不存在");
}
checkChildOrgNum(org, org.getParent());
org.setParent(p);
}
org.setOrderNum(orgDao.getMaxOrder(pid));
orgDao.add(org);
} }