`

java从数据库中查出来二次封装基于XML

    博客分类:
  • java
阅读更多
实现类似于mybatis的配置关系一对多或者一对一的实现:基于<XML>实现:
先上个配置文件
 <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper>

	<resultMap ID="manyMap" type="com.zfsy.entity.ProductDetailEntity">
		<id property="xh" column="xh"/>
		<result property="spmc" column="spmc"/>
		<result property="dj" column="dj"/>
		<result property="sppj" column="sppj"/>
		<result property="dw" column="dw"/>
		<result property="spms" column="spms"/>
		<collection property="images" ofType="com.zfsy.entity.ImageUrl">
			<!-- <id property="xh" column="bxh"/> -->
			<result property="lx" column="lx"/>
			<result property="tpurl" column="tpurl"/>
		</collection>
		 <association property="goodsType" ofType="com.stark.app.model.GoodsType">
			<id property="xh" column="cxh"/>
			<result property="mc" column="mc"/>
			<result property="ico" column="ico"/>
		</association>  
	</resultMap>

</mapper>

/** 
* @author 
* @version 创建时间:2017年3月20日 下午3:19:04 
* @description 对应xml中resultMap下的一条条记录
*/
public class ResultSetMapping {
	private String property;
	private String column;
	//private String collectionType;
	private String javaType;
	//对应collection和association标签下的result
	private List<ResultSetMapping> composites;
	
	/*public String getCollectionType() {
		return collectionType;
	}
	public void setCollectionType(String collectionType) {
		this.collectionType = collectionType;
	}*/
	public List<ResultSetMapping> getComposites() {
		return composites;
	}
	public void setComposites(List<ResultSetMapping> composites) {
		this.composites = composites;
	}
	public String getProperty() {
		return property;
	}
	public void setProperty(String property) {
		this.property = property;
	}
	public String getColumn() {
		return column;
	}
	public void setColumn(String column) {
		this.column = column;
	}
	public String getJavaType() {
		return javaType;
	}
	public void setJavaType(String javaType) {
		this.javaType = javaType;
	}
	
}


/** 
* @author 
* @version 创建时间:2017年3月20日 下午5:03:09 
* @description 对应整个resultMap配置文件的一些关键信息
*/
public class ResultMapper {
	private String id;
	private String classType;
	private List<ResultSetMapping> rsMapping;
	private boolean hasNest;
	
	public boolean isHasNest() {
		return hasNest;
	}
	public void setHasNest(boolean hasNest) {
		this.hasNest = hasNest;
	}
	public ResultMapper(String id, String classType, List<ResultSetMapping> rsMapping) {
		super();
		this.id = id;
		this.classType = classType;
		this.rsMapping = rsMapping;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getClassType() {
		return classType;
	}
	public void setClassType(String classType) {
		this.classType = classType;
	}
	public List<ResultSetMapping> getRsMapping() {
		return rsMapping;
	}
	public void setRsMapping(List<ResultSetMapping> rsMapping) {
		this.rsMapping = rsMapping;
	}
	
}

/**
 * @author 
 * @version 创建时间:2017年3月20日 下午3:37:17
 * @description 读取配置文件 封装数据到resultMapper
 */
public class Configuration {
	public ResultMapper loadXml(String path, String mapId) {
		SAXReader saxReader = new SAXReader();
		List<ResultSetMapping> mappings = new ArrayList<ResultSetMapping>();
		try {
			Document document = saxReader.read(this.getClass().getClassLoader().getResourceAsStream(path));
			Element element = document.getRootElement();
			Element node = element.elementByID(mapId);
			mappings = configMappings(node, mappings);
			ResultMapper mapper = new ResultMapper(node.element("id").attributeValue("property"), node.attributeValue("type"), mappings);
			if(node.element("collection")!=null){
				mapper.setHasNest(true);
			}
			return mapper;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	@SuppressWarnings("unchecked")
	private List<ResultSetMapping> configMappings(Element node, List<ResultSetMapping> mappings2) {
		ResultSetMapping resultSetMapping;
		ResultSetMapping cresultSetMapping;
		List<ResultSetMapping> cResultSetMapping;
		List<Element> elements = node.elements();
		for (Element element : elements) {
			resultSetMapping = new ResultSetMapping();
			if (element.getName().equals("collection")||element.getName().equals("association")){
				// resultSetMapping.setColumn(element.attributeValue("column"));
				cResultSetMapping = new ArrayList<ResultSetMapping>();
				resultSetMapping.setJavaType(element.attributeValue("ofType"));
				List<Element> celements = element.elements();

				for (Element element2 : celements) {
					cresultSetMapping = new ResultSetMapping();
					cresultSetMapping.setColumn(element2.attributeValue("column"));
					cresultSetMapping.setProperty(element2.attributeValue("property"));
					cResultSetMapping.add(cresultSetMapping);
				}
				resultSetMapping.setComposites(cResultSetMapping);
			} 
			resultSetMapping.setColumn(element.attributeValue("column"));
			resultSetMapping.setProperty(element.attributeValue("property"));
			mappings2.add(resultSetMapping);
		}
		return mappings2;
	}

}

/**
 * @author 
 * @version 创建时间:2017年3月20日 下午5:13:53
 * @description 组装数据
 */
public class BeanFactory {
	private Map<String, List<Object>> maps = new HashMap<String, List<Object>>();
	
	private String id;

	@SuppressWarnings("unchecked")
	public <T, E> List<E> getBeans(List<T> lists, ResultMapper resultMapper) {

		try {

			// Map<String, Object> objectMap = new HashMap<String, Object>();
			List<E> dataList = new ArrayList<E>();
			String id = resultMapper.getId();
			this.id = id;
			E targetObject = null;
			List<Object> composites;

			List<ResultSetMapping> resultSetMappings = resultMapper.getRsMapping();

			for (T t : lists) {

				if (!maps.containsKey(getValue(id, t))) {
					targetObject = (E) Class.forName(resultMapper.getClassType()).newInstance();
					// composites = new ArrayList<Object>();
					setData(targetObject, t, resultSetMappings);
					// maps.put(getValue(id, t).toString(), composites);
					dataList.add(targetObject);
				} else if (resultMapper.isHasNest()) {
					composites = maps.get(getValue(id, t));
					composites = setComposites(composites, t, resultSetMappings);
				}
				/*
				 * else { composites = maps.get(getValue(id, t)); composites =
				 * setComposites(composites, t, resultSetMappings); }
				 */
			}

			return dataList;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	private List<Object> setComposites(List<Object> composites, Object obj, List<ResultSetMapping> resultSetMappings) {
		String javaType;
		Object object;
		List<ResultSetMapping> compositesMappings;
		for (ResultSetMapping mapping : resultSetMappings) {
			javaType = mapping.getJavaType();
			if (javaType != null) {
				try {
					object = Class.forName(javaType).newInstance();
					compositesMappings = mapping.getComposites();
					setData(object, obj, compositesMappings);
					composites.add(object);
					return composites;
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		return null;
	}

	private <E> void setData(E targetObject, Object obj, List<ResultSetMapping> resultSetMappings) {
		String property;
		String javaType;
		Object value;
		Object object;
		String column;
		// Object nestObject;
		List<Object> composites;
		for (ResultSetMapping mapping : resultSetMappings) {
			property = mapping.getProperty();
			javaType = mapping.getJavaType();
			column = mapping.getColumn();
			if (javaType == null) {
				value = getValue(column, obj);
				setValue(value, property, targetObject);
			} else {
				try {
					// nestObject = getValue(property, targetObject);
					Field field = targetObject.getClass().getDeclaredField(property);
					if (field.getType().isAssignableFrom(List.class)) {
						composites = maps.get(getValue(id, obj));
						if (composites == null) {
							composites = new ArrayList<Object>();
							maps.put(getValue(id, obj).toString(), composites);
						}
						composites = setComposites(composites, obj, resultSetMappings);
						setValue(composites, property, targetObject);
					} else {
						object = Class.forName(javaType).newInstance();
						setAssociation(object, obj, mapping.getComposites());
						setValue(object, property, targetObject);
					}
				} catch (Exception e) {
				}
			}
		}

	}

	private void setAssociation(Object nestObject, Object obj, List<ResultSetMapping> composites) {
		String property;
		Object value;
		String column;
		for (ResultSetMapping mapping : composites) {
			property = mapping.getProperty();
			column = mapping.getColumn();
			value = getValue(column, obj);

			setValue(value, property, nestObject);
		}
	}

	private <E> void setValue(Object value, String property, E obj) {
		try {
			Field field = obj.getClass().getDeclaredField(property);
			field.setAccessible(true);
			field.set(obj, value);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public Object getValue(String property, Object obj) {
		try {
			Field field = obj.getClass().getDeclaredField(property);
			field.setAccessible(true);
			return field.get(obj);
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}
}




分享到:
评论

相关推荐

    (Java+JSP)可二次开发一个非常简单的mysqljava项目的增删查项目.zip

    该项目是一个基于Java和JSP技术实现的MySQL数据库的增删查操作系统,主要适用于初学者进行二次开发学习。下面将详细解析这个项目的关键知识点。 首先,`bishe018.sql`是数据库脚本文件,通常用于创建数据库结构和...

    Java与XML实现数据抽取

    为了从数据库中抽取数据,通常会使用Java Database Connectivity (JDBC) API。JDBC提供了一组标准接口,使得Java应用程序能够与各种关系型数据库进行交互。具体步骤如下: 1. **加载数据库驱动**:通过Class.for...

    Mybatis通用DAO设计封装(mybatis)

    Mybatis通用DAO设计封装主要涉及的是在Java开发中如何高效地使用Mybatis框架进行数据库操作。Mybatis是一款轻量级的持久层框架,它避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。通过提供自定义SQL、存储...

    基于Java web SSM框架的权限管理系统(源码+数据库).zip

    这个系统提供了源码,方便开发者进行学习和二次开发。下面将详细讲解该系统的组成部分和实现技术。 1. **Spring框架**:Spring是Java企业级应用的核心框架,它提供了一个容器来管理对象的生命周期和依赖关系。在这...

    重新封装mybatis-generator

    2. **二次封装**:当原生工具无法满足特定需求时,开发者会对其进行改造以增加新功能或优化性能,这就是二次封装。在这个例子中,封装增加了批量操作支持。 3. **批量插入(batchInsert)**:在数据库操作中,批量...

    Java分页技术+数据库

    Java分页技术是Java开发中常见的一种功能,用于在大量数据中进行有效的浏览,提高用户体验。在处理数据库查询时,如果一次性加载所有记录,不仅会消耗大量内存,也可能导致页面响应速度变慢。因此,分页技术应运而生...

    struts2中的doubleSelect标签的用法(从数据库中读取数据,HSS)

    具体来说,需要实现`findSort_`方法,该方法用于从数据库中查询数据,并将其封装成适合`doubleSelect`使用的格式。 ```java public String findSort_(){ try{ pslist = service.findSortOne(); List...

    redisTemplate封装成redisUtils和分布式锁实现

    RedisTemplate是Spring Data Redis模块中的一个核心组件,用于在Java应用中操作Redis数据库。它提供了一种面向对象的方式来执行各种Redis命令,简化了与Redis的数据交互。本篇将深入探讨如何将RedisTemplate封装成...

    HIBERNATE - 符合Java习惯的关系数据库持久化

    它是对数据库的配置和映射信息的封装,通常在应用启动时创建一次,然后在整个应用生命周期内复用。 5. **Criteria查询**:Hibernate提供了Criteria API,允许以面向对象的方式进行数据库查询,无需编写SQL语句。...

    JAVA上百实例源码以及开源项目源代码

    Java从网络取得文件 1个目标文件 简单 Java从压缩包中提取文件 1个目标文件 简单 Java存储与读取对象 1个目标文件 如题 Java调色板面板源代码 1个目标文件 摘要:Java源码,窗体界面,调色板 使用Java语言编写的一款...

    基于jsp的智能网络教学系统源码数据库.zip

    描述中的信息与标题一致,"基于jsp的智能网络教学系统源码数据库.zip",确认了这是一个以JSP为开发语言的项目,其核心功能是构建一个智能网络教学环境,并且提供源代码和数据库的完整打包,可能是为了便于学习、分析...

    基于jsp+servlet+mysql的通用型信息管理系统,文件管理系统源码+数据库

    该系统主要目的是实现文件管理功能,并且提供了完整的源代码和数据库,非常适合学习者或者开发者进行二次开发或者理解Web应用程序的工作原理。 首先,我们来看这个系统的软件架构。JSP是Java的一种动态网页技术,它...

    java的ssm框架的完整项目

    本项目基于SSM框架构建了一个完整的小型应用程序,适合初学者进行学习或者开发者进行二次开发。以下是关于SSM框架及其在该项目中的应用的详细知识点: 1. **Spring框架**:Spring是Java企业级应用的核心框架,它...

    java开源包6

    WARTS是一个纯Java数据库工具,可以执行字符编码识别的数据同步。开发它是用于在UTF-8 Oracle实例中使用ASCII编码的Oracle 数据库中来正确的传输非ASCII字符。 Java模板语言 Beetl Beetl,是Bee Template Language的...

    java开源包4

    WARTS是一个纯Java数据库工具,可以执行字符编码识别的数据同步。开发它是用于在UTF-8 Oracle实例中使用ASCII编码的Oracle 数据库中来正确的传输非ASCII字符。 Java模板语言 Beetl Beetl,是Bee Template Language的...

    基于Java+JSP的博客系统源码.rar

    开发者或者学习者可以通过解压这个RAR文件,查看并理解代码结构,甚至进行二次开发或学习Java和JSP的应用实践。 【标签】: "基于Java+JSP的博客系统源" 标签再次确认了这个项目的核心技术栈,即Java和JSP,以及它...

    java开源包9

    WARTS是一个纯Java数据库工具,可以执行字符编码识别的数据同步。开发它是用于在UTF-8 Oracle实例中使用ASCII编码的Oracle 数据库中来正确的传输非ASCII字符。 Java模板语言 Beetl Beetl,是Bee Template Language的...

    java开源包101

    WARTS是一个纯Java数据库工具,可以执行字符编码识别的数据同步。开发它是用于在UTF-8 Oracle实例中使用ASCII编码的Oracle 数据库中来正确的传输非ASCII字符。 Java模板语言 Beetl Beetl,是Bee Template Language的...

Global site tag (gtag.js) - Google Analytics