当前位置:  编程技术>软件工程/软件设计

[1]Hibernate从入门到精通（四）基本映射

映射的概念        在上次的博文Hibernate从入门到精通（三）Hibernate配置文件我们已经讲解了一下Hibernate中的两种配置文件，其中提到了两种配置文件的主要区别就是XML可以配置映射。这里提到的映射即对象关系映射(Object Relational Mapping)。ORM的实现目的就是将对象数据保存到数据库中，同时可以将数据库数据读入对象中，这样开发人员就可以将对数据库数据的操作转化为对这些对象的操作。

基本映射        了解了映射的意义和概念之后，我们来讲解一下映射的分类。从映射的概念来看，单个的数据库表可以映射成为一个对象，抛开Hibernate不谈，这种思路在很多项目开发中时常见的，即根据表结构创建相应实体类，这种简单的映射关系在Hibernate映射中被称为基本映射。

基本映射实例

如下图所示的表结构：

经过转换之后，可以创建相应的对象，代码如下:

		public class User{
			private String id;	
			private String name;
			
			public String getId() {
				return id;
			}
			public void setId(String id) {
				this.id = id;
			}
			public String getName() {
				return name;
			}
			public void setName(String name) {
				this.name = name;
			}
		}

对于Hibernate来讲，仅仅是有上面的还是不够的，还需要一个XML格式的映射文件User.hbm.xml，代码如下:

		<?xml version="1.0"?>
		<!DOCTYPE hibernate-mapping PUBLIC 
			"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
			"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
		<hibernate-mapping package="com.bjpowernode.hibernate">
			<class name="User1" table="t_user1">
				<id name="id" column="user_id" length="32" access="field">
					<generator class="uuid"/>
				</id>
				<property name="name" length="30" unique="true" not-null="true"/>				
			</class>
		</hibernate-mapping>

注解配置基本映射实例 除了上述XML方式配置映射外，还可以通过给类文件添加注解的方式配置映射，具体代码如下:

		@Entity
		@Table(name="t_user")
		public class User{
			@Id
			private String id;	
			@GeneratedValue
			private String name;
			
			public String getId() {
				return id;
			}
			public void setId(String id) {
				this.id = id;
			}
			public String getName() {
				return name;
			}
			public void setName(String name) {
				this.name = name;
			}
		}

    

       到此，映射的基本概念和简单实用，我们就算是讲解完毕了，对于映射配置中的一些细节问题，例如:@Entity,@Table的使用说明等等，建议大家找一本注解和XML配置相关的说明文档进行学习，这里就不再给大家进行讲解了。下次我们讲解一些稍微复杂一点的映射。

[2]设计模式10---设计模式之原型模式（Prototype）

1.场景模式 考虑这样一个实际应用：订单处理系统
里面有一个保存订单的功能，当产品数量超过1000份以后，拆成两份订单，再超，那么就再拆。直到每份订单不超过1000为止，订单有两种，一个是个人订单，一个是公司订单，现在需要实现一个通用的订单处理系统。
2.场景模式代码（代码很简单，不一一讲解了）

package demo08.prototype.example1;


/**
 * 订单的接口
 */
public interface OrderApi {
	/**
	 * 获取订单产品数量
	 * 
	 * @return 订单中产品数量
	 */
	public int getOrderProductNum();


	/**
	 * 设置订单产品数量
	 * 
	 * @param num
	 *        订单产品数量
	 */
	public void setOrderProductNum(int num);
}

package demo08.prototype.example1;


/**
 * 个人订单对象
 */
public class PersonalOrder implements OrderApi {
	/**
	 * 订购人员姓名
	 */
	private String customerName;
	/**
	 * 产品编号
	 */
	private String productId;
	/**
	 * 订单产品数量
	 */
	private int orderProductNum = 0;


	public int getOrderProductNum() {
		return this.orderProductNum;
	}


	public void setOrderProductNum(int num) {
		this.orderProductNum = num;
	}


	public String getCustomerName() {
		return customerName;
	}


	public void setCustomerName(String customerName) {
		this.customerName = customerName;
	}


	public String getProductId() {
		return productId;
	}


	public void setProductId(String productId) {
		this.productId = productId;
	}


	public String toString() {
		return "本个人订单的订购人是=" + this.customerName + "，订购产品是=" + this.productId + "，订购数量为=" + this.orderProductNum;
	}
}

package demo08.prototype.example1;


/**
 * 企业订单对象
 */
public class EnterpriseOrder implements OrderApi {
	/**
	 * 企业名称
	 */
	private String enterpriseName;
	/**
	 * 产品编号
	 */
	private String productId;
	/**
	 * 订单产品数量
	 */
	private int orderProductNum = 0;


	public int getOrderProductNum() {
		return this.orderProductNum;
	}


	public void setOrderProductNum(int num) {
		this.orderProductNum = num;
	}


	public String getEnterpriseName() {
		return enterpriseName;
	}


	public void setEnterpriseName(String enterpriseName) {
		this.enterpriseName = enterpriseName;
	}


	public String getProductId() {
		return productId;
	}


	public void setProductId(String productId) {
		this.productId = productId;
	}


	public String toString() {
		return "本企业订单的订购企业是=" + this.enterpriseName + "，订购产品是=" + this.productId + "，订购数量为=" + this.orderProductNum;
	}
}

package demo08.prototype.example1;


/**
 * 处理订单的业务对象
 */
public class OrderBusiness {
	/**
	 * 创建订单的方法
	 * 
	 * @param order
	 *        订单的接口对象
	 */
	public void saveOrder(OrderApi order) {
		// 根据业务要求，当订单的预定的产品数量超过1000的时候，就需要把订单拆成两份订单
		// 当然如果要做好，这里的1000应该做成常量，这么做是为了演示简单


		// 1：判断当前的预定产品数量是否大于1000
		while (order.getOrderProductNum() > 1000) {
			// 2：如果大于，还需要继续拆分
			// 2.1再新建一份订单，跟传入的订单除了数量不一样外，其他都相同
			OrderApi newOrder = null;
			if (order instanceof PersonalOrder) {
				// 创建相应的新的订单对象
				PersonalOrder p2 = new PersonalOrder();
				// 然后进行赋值，但是产品数量为1000
				PersonalOrder p1 = (PersonalOrder) order;
				p2.setCustomerName(p1.getCustomerName());
				p2.setProductId(p1.getProductId());
				p2.setOrderProductNum(1000);
				// 然后再设置给newOrder
				newOrder = p2;
			} else if (order instanceof EnterpriseOrder) {
				// 创建相应的订单对象
				EnterpriseOrder e2 = new EnterpriseOrder();
				// 然后进行赋值，但是产品数量为1000
				EnterpriseOrder e1 = (EnterpriseOrder) order;
				e2.setEnterpriseName(e1.getEnterpriseName());
				e2.setProductId(e1.getProductId());
				e2.setOrderProductNum(1000);
				// 然后再设置给newOrder
				newOrder = e2;
			}


			// 2.2原来的订单保留，把数量设置成减少1000
			order.setOrderProductNum(order.getOrderProductNum() - 1000);


			// 然后是业务功能处理，省略了，打印输出，看一下
			System.out.println("拆分生成订单==" + newOrder);
		}


		// 3：不超过，那就直接业务功能处理，省略了，打印输出，看一下
		System.out.println("订单==" + order);


	}


//	public void saveOrder2(OrderApi order){
//		int oldNum = order.getOrderProductNum();
//		while(oldNum > 1000){
//			//定义一个表示被拆分出来的新订单对象
//			OrderApi newOrder = null;
//			
//			if(order instanceof PersonalOrder){
//				//创建相应的订单对象
//				PersonalOrder p2 = new PersonalOrder();
//				//然后进行赋值等，省略了
//				//然后再设置给newOrder
//				newOrder = p2;
//			}else if(order instanceof EnterpriseOrder){
//				//创建相应的订单对象
//				EnterpriseOrder e2 = new EnterpriseOrder();
//				//然后进行赋值等，省略了
//				//然后再设置给newOrder
//				newOrder = e2;
//			}			
//			//然后进行拆分和其他业务功能处理，省略了
//		}		
//	}
}

package demo08.prototype.example1;


public class OrderClient {
	public static void main(String[] args) {
		// 创建订单对象，这里为了演示简单，直接new了
		PersonalOrder op = new PersonalOrder();
		// 设置订单数据
		op.setOrderProductNum(2925);
		op.setCustomerName("张三");
		op.setProductId("P0001");


		// 这里获取业务处理的类，也直接new了，为了简单，连业务接口都没有做
		OrderBusiness ob = new OrderBusiness();
		// 调用业务来保存订单对象
		ob.saveOrder(op);
	}
}

3.问题所在 仔细观察可以发现：实际上是关注订单的类型和具体实现的。证据如下：

		// 1：判断当前的预定产品数量是否大于1000
		while (order.getOrderProductNum() > 1000) {
			// 2：如果大于，还需要继续拆分
			// 2.1再新建一份订单，跟传入的订单除了数量不一样外，其他都相同
			OrderApi newOrder = null;
			if (order instanceof PersonalOrder) {
				// 创建相应的新的订单对象
				PersonalOrder p2 = new PersonalOrder();
				// 然后进行赋值，但是产品数量为1000
				PersonalOrder p1 = (PersonalOrder) order;
				p2.setCustomerName(p1.getCustomerName());
				p2.setProductId(p1.getProductId());
				p2.setOrderProductNum(1000);
				// 然后再设置给newOrder
				newOrder = p2;
			} else if (order instanceof EnterpriseOrder) {
				// 创建相应的订单对象
				EnterpriseOrder e2 = new EnterpriseOrder();
				// 然后进行赋值，但是产品数量为1000
				EnterpriseOrder e1 = (EnterpriseOrder) order;
				e2.setEnterpriseName(e1.getEnterpriseName());
				e2.setProductId(e1.getProductId());
				e2.setOrderProductNum(1000);
				// 然后再设置给newOrder
				newOrder = e2;
			}


			// 2.2原来的订单保留，把数量设置成减少1000
			order.setOrderProductNum(order.getOrderProductNum() - 1000);


			// 然后是业务功能处理，省略了，打印输出，看一下
			System.out.println("拆分生成订单==" + newOrder);
		}

4.解决方案 是不是觉得上面代码很臃肿，很不爽，很不舒服，对头，这样说明你已经开始理解java设计模式的好处了。
解决它的方法就是使用原型模式
5.原型模式 5.1原型模式定义： 用原型实例指定创建对象的种类，并通过拷贝这些原型创新新的对象。
5.2如何解决 那么如何解决呢？大家有没有想过可以把这些复制的代码放在接口中，返回接口对象，这样就好像是接口创建了接口对象似的。而且，客户端就不用理解对象的一些操作了，知识最少化。
6.原型模式示例代码 6.1模式结构图  
6.2声明一个克隆自身的接口

package demo08.prototype.example2;
/**
 * 声明一个克隆自身的接口
 */
public interface Prototype {
	/**
	 * 克隆自身的方法
	 * @return 一个从自身克隆出来的对象
	 */
	public Prototype clone();
}

6.3具体的实现对象

package demo08.prototype.example2;
/**
 * 克隆的具体实现对象
 */
public class ConcretePrototype1 implements Prototype {
	public Prototype clone() {
		//最简单的克隆，新建一个自身对象，由于没有属性，就不去复制值了
		Prototype prototype = new ConcretePrototype1();
		return prototype;
	}
}
package demo08.prototype.example2;


/**
 * 克隆的具体实现对象
 */
public class ConcretePrototype2 implements Prototype {
	public Prototype clone() {
		//最简单的克隆，新建一个自身对象，由于没有属性，就不去复制值了
		Prototype prototype = new ConcretePrototype2();
		return prototype;
	}
}

6.4客户端

package demo08.prototype.example2;


/**
 * 使用原型的客户端
 */
public class Client {
	/**
	 * 持有需要使用的原型接口对象
	 */
	private Prototype prototype;


	/**
	 * 构造方法，传入需要使用的原型接口对象
	 * 
	 * @param prototype
	 *        需要      

      
      
    

      

[3]Dreamer 3.0 支持json、xml、文件上传

自己写的框架，功能类似Struts2.x

下载地址：http://pan.baidu.com/share/link?shareid=3273223286&uk=470382596

新增功能：

1、Action支持输出JSON、XML、TEXT

2、新增文件上传封装

直接用File 类型的字段来接收文件，就可以进行操作，框架运行时，会在服务器创建一个tmp文件夹用来存放临时的文件。

3、优化Action管理器

4、优化处理逻辑

具体例子和源码都在下载连接中。