在项目中,我们经常会写到一些公共的代码,来让开发人员调用,减少代码重复,下面,我就将一些常用到的公共类贴出来和大家分享!!
在我们的项目中,经常会出现dao、daoImpl、service、serviceImpl这样操作数据库的类出现,然而我们在使用它们的时候都会在相应的类中通过new关键字生成其对象,然后调用里面相应的操作方法,这样有一个弊端出现,对象不好管理,程序的拓展性能比较差,当我们要修改相应的实现类的时候还要在类中进行修改,不好维护,所以我们将这些类中定义在一个XML配置文件中,程序员只要写好相应的类进行配置,然后调用公共类我们的对象就帮你生成好了,代码实现如下:
1、编写相应的Dao类和实现类:
package com.common.beanmanage;
public interface Dao {
public void addUser();
public void addUserCount();
}
package com.common.beanmanage;
public class DaoImpl implements Dao {
@Override
public void addUser() {
System.out.println("增加用户");
}
@Override
public void addUserCount() {
System.out.println("增加用户账单");
}
}
package com.common.beanmanage;
public interface Service {
public void add();
}
package com.common.beanmanage;
public class ServiceImpl implements Service{
private Dao dao;
public ServiceImpl(){
this.dao=(DaoImpl)BeanFactory.getInstance().getDaoObject(Dao.class);
}
@Override
public void add() {
dao.addUser();
dao.addUserCount();
}
}
2、在配置文件中进行配置:beans.xml(相当于Spring中的依赖注入)
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="com.common.beanmanage" class="com.common.beanmanage.DaoImpl"></bean>
<bean id="com.common.beanmanage.Dao" class="com.common.beanmanage.DaoImpl"></bean>
<bean id="com.common.beanmanage.Service" class="com.common.beanmanage.ServiceImpl"></bean>
</beans>
3、编写生成实例的工厂类:
package com.common.beanmanage;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
/**
* 创建Bean对象的管理类,对Bean对象进行管理
* 运用到的设计模式:单例模式和工厂模式
* @author Administrator
*
*/
public class BeanFactory {
private Document doc=null;
private Map daoMap=new HashMap();//将class和创建好的对象放在Map中
private Map serviceMap=new HashMap();//将class和创建好的对象放在Map中
private static BeanFactory instance=new BeanFactory();//创建单例
//构造函数,解析XML
private BeanFactory(){
try {
doc=new SAXReader().read(Thread.currentThread().getContextClassLoader().getResourceAsStream("beans.xml"));
} catch (DocumentException e) {
e.printStackTrace();
}
}
//生成dao的实例,不需要进行事物封装
public synchronized Object getDaoObject(Class c){
if(daoMap.containsKey(c.getName())){
return daoMap.get(c.getName());
}
Element root = doc.getRootElement();
List<Element> list=root.elements("bean");
String className=null;
Object obj=null;
for(Element e:list){
if(e.attribute("id").getStringValue().equals(c.getName())){
className=e.attributeValue("class");
break;
}
}
if(className!=null){
try {
obj=Class.forName(className).newInstance();
daoMap.put(c.getName(), obj);
} catch (InstantiationException e1) {
e1.printStackTrace();
} catch (IllegalAccessException e1) {
e1.printStackTrace();
} catch (ClassNotFoundException e1) {
e1.printStackTrace();
}
}
return obj;
}
//生成service的实例,需要进行事物的封装
public synchronized Object getServiceObject(Class c){
if(serviceMap.containsKey(c.getName())){
return serviceMap.get(c.getName());
}
Element root = doc.getRootElement();
List<Element> list=root.elements("bean");
String className=null;
Object obj=null;
for(Element e:list){
if(e.attribute("id").getStringValue().equals(c.getName())){
className=e.attributeValue("class");
break;
}
}
if(className!=null){
try {
obj=Class.forName(className).newInstance();
//当业务逻辑有事务需要处理的时候,对对象进行一层封装
TransactionHandler handler=new TransactionHandler();
obj=handler.newProxyInstance(obj);
serviceMap.put(c.getName(), obj);
} catch (InstantiationException e1) {
e1.printStackTrace();
} catch (IllegalAccessException e1) {
e1.printStackTrace();
} catch (ClassNotFoundException e1) {
e1.printStackTrace();
}
}
return obj;
}
public static BeanFactory getInstance(){
return instance;
}
}
4、如果有事务要进行处理,我们还可以使用动态代理模式对事务进行封装处理,交给程序去处理,用户不用自己在方法中添加事务开启、提交或者回滚操作,使用代理模式实现
相当于Spring中的AOP,面向切面编程,一般在service方法里面对其进行封装,如上面的生成service实例
package com.common.beanmanage;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import com.common.db.ConnectionManager;
import com.common.db.DbUtil;
/**
* 采用代理模式封装对事务的处理
*
* @author Administrator
*
*/
public class TransactionHandler implements InvocationHandler {
private Object targetObject;
public Object newProxyInstance(Object targetObject) {
this.targetObject = targetObject;
return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
targetObject.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Connection conn = null;
Object ret = null;
try {
//从ThreadLocal中取得Connection
conn = ConnectionManager.getConnection();
if (method.getName().startsWith("add") ||
method.getName().startsWith("del") ||
method.getName().startsWith("modify")) {
//手动控制事务提交
DbUtil.beginTransaction(conn);
System.out.println("开启事物");
}
//调用目标对象的业务逻辑方法
ret = method.invoke(targetObject, args);
if (!conn.getAutoCommit()) {
//提交事务
DbUtil.commitTransaction(conn);
System.out.println("提交事物");
}
// }catch(ApplicationException e) {
// if (!conn.getAutoCommit()) {
// //回滚事务
// ConnectionManager.rollbackTransaction(conn);
// }
// throw e;
}catch(Exception e) {
e.printStackTrace();
if (e instanceof InvocationTargetException) {
InvocationTargetException ete = (InvocationTargetException)e;
throw ete.getTargetException();
}
if (!conn.getAutoCommit()) {
//回滚事务
System.out.println("出现异常,不能提交");
DbUtil.rollbackTransaction(conn);
}
//throw new ApplicationException("操作失败!");
}finally {
DbUtil.close(conn);
}
return ret;
}
}
5、编写我们的测试类
package com.common.beanmanage;
public class Client {
private static Service service;
static{
service=(Service)BeanFactory.getInstance().getServiceObject(Service.class);
}
public static void main(String[] args) {
//service=(Service)BeanFactory.getInstance().getServiceObject(Service.class);
service.add();
}
}
这样,我们在程序里面不用通过new关键字来实现对象的生成,而是通过配置文件,由程序解析配置文件帮我们实现了,并且在service的实现类中,我们不用考虑事务的操作了,
只要编写我们的业务逻辑的实现即可,通过动态代理模式帮我们把事务给处理好了,在这个里面,我们实际上模仿了Spring中的AOP和IOC的基本实现!大家可以思考一下,
灵活运用。
分享到:
相关推荐
spring ioc容器初始化流程图 spring ioc容器依赖注入流程图 spring aop实现原理流程图
以注解方式模拟Spring IoC AOP,了解Spring是如何实现的.
控制反转(Inversion of Control,缩写为IoC),是面向对象编程中的一种设计原则,可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入(Dependency Injection,简称DI),还有一种方式叫“依赖查找...
SpringIOC和AOP实现机制模拟,来自与网络。
springIOC与AOP配置
介绍下spring的ioc和aop的定义
关于Spring的IOC和AOP的例子,帮助初学者入门。 内有bean的声明、注入;切入点和通知等功能例子。 环境配置:myeclipse, spring2.5
spring基础Spring IOC和Spring AOP的原理及使用
Spring_IOC_AOP总结,有代码详细讲解了springIOC和AOP的功能,是你学习三大框架的必备
基于Cglib简单实现Spring体系(Ioc+Aop+Mvc)基于Cglib简单实现Spring体系(Ioc+Aop+Mvc)基于Cglib简单实现Spring体系(Ioc+Aop+Mvc)基于Cglib简单实现Spring体系(Ioc+Aop+Mvc)基于Cglib简单实现Spring体系(Ioc+Aop+Mvc)...
初学者认识和书写Spring IoC 和AOP
Spring IOC AOP MVC 简单例子
彻底学会Spring的IOC和AOP——理论+实操,参考:https://blog.csdn.net/qq_39735940/article/details/121754987
Spring IOC、AOP实现代码,可调试查看内部原理,简单易懂
Spring的核心:IOC与AOP。IOC是控制反转或依赖注入,AOP是面向切面编程。
内含spring ioc,aop例子,了解IOC,AOP原理
Spring的Aop和Ioc示例代码,代码通过了调试的,没得问题.对于初学者理解和使用Spring的Aop和Ioc是够了.
浅谈 Spring 原理 透析,ioc aop
Spring IOC AOP学习示例代码,包含Spring常用操作示例和所有所需jar文件。参考博客:http://blog.csdn.net/daijin888888/article/details/51735291
Spring中IOC/AOP的说明和例子