• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

附有源码。

对快速小型web应用很有效。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

Object java.lang.reflect.Proxy.newProxyInstance(ClassLoader loader, 
             Class<?>[] interfaces, 
             InvocationHandler h) throws IllegalArgumentException

public Object invoke(Object proxy, Method method, 
                  Object[] args) throws Throwable;

package com.cyh.proxy.sample;

public interface IUser {
    public String getName();

    public void setName(String name);
}

package com.cyh.proxy.sample.impl;

import com.cyh.proxy.sample.IUser;

public class User implements IUser {
    String name;

    public User(String name) {
	this.name = name;
    }

    public String getName() {
	return name;
    }

    public void setName(String name) {
	this.name = name;
    }
}

package com.cyh.proxy.sample.impl;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class TraceHandler implements InvocationHandler {
    private Object target;

    public TraceHandler(Object target) {
	this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args)
	    throws Throwable {

	// print implicit argument
	System.out.print(target.getClass().getName());
	// print method name
	System.out.print("." + method.getName() + "(");
	// print explicit arguments
	if (args != null) {
	    for (int i = 0; i < args.length; i++) {
		System.out.print(args[i]);
		if (i < args.length - 1) {
		    System.out.print(",");
		}
	    }
	}
	System.out.println(")");

	return method.invoke(this.target, args);
    }
}

package com.cyh.proxy.sample.test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

import com.cyh.proxy.sample.IUser;
import com.cyh.proxy.sample.impl.TraceHandler;
import com.cyh.proxy.sample.impl.User;

public class ProxyTest {
    User user;

    public ProxyTest() {
	user = new User("LaraCroft");

	ClassLoader classLoader = user.getClass().getClassLoader();
	Class[] interfaces = user.getClass().getInterfaces();
	InvocationHandler handler = new TraceHandler(user);
	IUser proxy = (User) Proxy.newProxyInstance(classLoader, interfaces,
		handler);

	proxy.setName("David Beckham");
    }

    public static void main(String[] args) {
	new ProxyTest();
    }

}

package com.cyh.proxy.interceptor;

public interface DynamicProxyFactory {
    /**
     * 生成动态代理,并且在调用代理执行函数的时候使用拦截器
     * 
     * @param clazz
     *            需要实现的接口
     * @param target
     *            实现此接口的类
     * @param interceptor
     *            拦截器
     * @return
     */
    public <T> T createProxy(T target, Interceptor interceptor);
}

package com.cyh.proxy.interceptor;

import java.lang.reflect.Method;

public interface Interceptor {
    public void before(Method method, Object[] args);

    public void after(Method method, Object[] args);

    public void afterThrowing(Method method, Object[] args, Throwable throwable);

    public void afterFinally(Method method, Object[] args);
}

package com.cyh.proxy.interceptor.impl;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

import com.cyh.proxy.interceptor.DynamicProxyFactory;
import com.cyh.proxy.interceptor.Interceptor;

public class DynamicProxyFactoryImpl implements DynamicProxyFactory {
    /**
     * 生成动态代理,并且在调用代理执行函数的时候使用拦截器
     * 
     * @param target
     *  需要代理的实例
     * @param interceptor
     *  拦截器实现,就是我们希望代理类执行函数的前后,
     *  抛出异常,finally的时候去做写什么
     */
    @Override
    @SuppressWarnings("unchecked")
    public <T> T createProxy(T target, Interceptor interceptor) {
	// 当前对象的类加载器
	ClassLoader classLoader = target.getClass().getClassLoader();
	// 获取此对象实现的所有接口
	Class<?>[] interfaces = target.getClass().getInterfaces();
	// 利用DynamicProxyInvocationHandler类来实现InvocationHandler
	InvocationHandler handler = new DynamicProxyInvocationHandler(target,
		interceptor);

	return (T) Proxy.newProxyInstance(classLoader, interfaces, handler);
    }
}

package com.cyh.proxy.interceptor.impl;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

import com.cyh.proxy.interceptor.Interceptor;

/**
 * 动态代理的调用处理器
 * 
 * @author chen.yinghua
 */
public class DynamicProxyInvocationHandler implements InvocationHandler {
    private Object target;
    private Interceptor interceptor;

    /**
     * @param target
     *            需要代理的实例
     * @param interceptor
     *            拦截器
     */
    public DynamicProxyInvocationHandler(Object target,
                                  Interceptor interceptor) {
	this.target = target;
	this.interceptor = interceptor;
    }

    /**
     * @param proxy
     *            所生成的代理对象
     * @param method
     *            调用的方法示例
     * @args args 参数数组
     * @Override
     */
    public Object invoke(Object proxy, Method method, Object[] args)
	    throws Throwable {
	Object result = null;

	try {
	    // 在执行method之前调用interceptor去做什么事
	    this.interceptor.before(method, args);
	    // 在这里我们调用原始实例的method
	    result = method.invoke(this.target, args);
	    // 在执行method之后调用interceptor去做什么事
	    this.interceptor.after(method, args);
	} catch (Throwable throwable) {
	    // 在发生异常之后调用interceptor去做什么事
	    this.interceptor.afterThrowing(method, args, throwable);
	    throw throwable;
	} finally {
	    // 在finally之后调用interceptor去做什么事
	    interceptor.afterFinally(method, args);
	}

	return result;
    }

}

package com.cyh.proxy.interceptor.test;

public interface Service {
    public String greet(String name);
}

package com.cyh.proxy.interceptor.test;

public class ServiceImpl implements Service {
    @Override
    public String greet(String name) {
	String result = "Hello, " + name;
	System.out.println(result);
	return result;
    }
}

package com.cyh.proxy.interceptor.test;

import java.lang.reflect.Method;

import com.cyh.proxy.interceptor.Interceptor;

public class InterceptorImpl implements Interceptor {
    @Override
    public void after(Method method, Object[] args) {
	System.out.println("after invoking method: " + method.getName());
    }

    @Override
    public void afterFinally(Method method, Object[] args) {
	System.out.println("afterFinally invoking method: " + method.getName());
    }

    @Override
    public void afterThrowing(Method method, Object[] args, 
                                Throwable throwable) {
	System.out.println("afterThrowing invoking method: "
                                                + method.getName());
    }

    @Override
    public void before(Method method, Object[] args) {
	System.out.println("before invoking method: " + method.getName());
    }
}

package com.cyh.proxy.interceptor.test;

import com.cyh.proxy.interceptor.DynamicProxyFactory;
import com.cyh.proxy.interceptor.Interceptor;
import com.cyh.proxy.interceptor.impl.DynamicProxyFactoryImpl;

public class TestDynamicProxy {
    public TestDynamicProxy() {
	DynamicProxyFactory dynamicProxyFactory = new DynamicProxyFactoryImpl();
	Interceptor interceptor = new InterceptorImpl();
	Service service = new ServiceImpl();

	Service proxy = dynamicProxyFactory.createProxy(service, interceptor);
	// Service proxy = DefaultProxyFactory.createProxy(service,
	// interceptor);
	proxy.greet("iwindyforest");
    }

    public static void main(String[] args) {
	new TestDynamicProxy();
    }
}

package com.cyh.proxy.interceptor.impl;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

import com.cyh.proxy.interceptor.Interceptor;

public class DefaultProxyFactory {
    @SuppressWarnings("unchecked")
    public static <T> T createProxy(T target, Interceptor interceptor) {
	// 当前对象的类加载器
	ClassLoader classLoader = target.getClass().getClassLoader();
	// 获取此对象实现的所有接口
	Class<?>[] interfaces = target.getClass().getInterfaces();
	// 利用DynamicProxyInvocationHandler类来实现InvocationHandler
	InvocationHandler handler = new DynamicProxyInvocationHandler(target,
		interceptor);

	return (T) Proxy.newProxyInstance(classLoader, interfaces, handler);
    }
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

package image;

import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.PixelGrabber;
import java.io.File;
import java.io.FileOutputStream;

import javax.imageio.ImageIO;

import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageEncoder;

public class WaterMark {

    /**
     * 获取指定矩形中的像素的矩阵
     * 
     * @param imageSrc
     * @param startX
     * @param startY
     * @param w
     * @param h
     * @return
     */
    private int[] getPixArray(Image imageSrc, int startX, int startY,
            int w, int h) {
        int[] pix = new int[(w - startX) * (h - startY)];
        
        /*下面是别人程序中的一段,我实在不明白为何要加这一段,因为我去掉也没有问题,加上还会报错*/
        PixelGrabber pg = null;
        try {
            pg = new PixelGrabber(imageSrc, startX, startY, w-startX, h-startY, pix, 0, w);
            if (pg.grabPixels() != true) {
                try {
                    throw new java.awt.AWTException("pg error" + pg.status());
                } catch (Exception eq) {
                    eq.printStackTrace();
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return pix;
    }

    /**
     * 将1张图片和另1张图片的指定区域重合。可用于制作水印。图片的左上角坐标为0，0
     * 
     * @param lightnessWaterImg
     *            颜色比较亮的水印图片，适合底色比较暗的情况
     * @param darknessWaterImg
     *            颜色比较暗的水印图片，适合底色比较亮的情况,如果不想区分，则输入null，平均灰度边界同时失效。
     * @param targetImg
     *            源图片
     * @param startX
     * @param startY
     * @param x
     * @param y
     * @param alpha
     *            透明度,0f为全透明,1f为完全不透明,0.5f为半透明
     * @param averageGray
     *            平均灰度边界（0-255），大于此值，则打暗的水印图片，小于此值则打亮的水印图片。
     *            默认值128。超过范围，按默认值进行。
     */
    private final void pressImage(String lightnessWaterImg,
            String darknessWaterImg, String targetImg, int startX, int startY,
            int x, int y, float alpha, float averageGray) {
        try {
            // 先判断亮水印和源文件的值是否为null，否则抛出异常
            if (lightnessWaterImg == null || lightnessWaterImg == ""
                    || targetImg == null || targetImg == "") {
                throw new Exception("亮水印或者源图片的地址不能为空");
            } 
            // 再判断平均灰度边界是否越界
            if (averageGray>255||averageGray<0) {
                averageGray = 128;
            }
            

            // 装载源图片
            File _file = new File(targetImg);
            // 图片装入内存
            BufferedImage src = ImageIO.read(_file);
            // 获取图片的尺寸
            int width = src.getWidth(null);
            int height = src.getHeight(null);
            // 根据源图片尺寸，设置预装载的一个图片，默认是RGB格式的
            BufferedImage image = new BufferedImage(width, height,
                    BufferedImage.TYPE_INT_RGB);
            Graphics2D graphics = image.createGraphics();
            // 绘制内存中的源图片至指定的矩形内
            graphics.drawImage(src, 0, 0, width, height, null);
            // 在已经绘制的图片中加入透明度通道
            graphics.setComposite(AlphaComposite.getInstance(
                    AlphaComposite.SRC_ATOP, alpha));
            

            // 获取源图片中和设定的同样大小的区域内的像素集合
            int[] pixels = getPixArray(src, startX, startY, x, y);

            //查询此集合的平均灰度
            float average = getAverageGrap(x-startX,y-startY,pixels);

            // 如果平均灰度大于130,则说明此区域比较亮，否则则比较暗
            System.out.println(average);

            
            //装载水印图片所需参数
            File water;
            BufferedImage bufferwater;
            
            // 根据设定的平均灰度边界来装载不同的水印
            if (darknessWaterImg == null||average>=averageGray) {
                // 装载亮水印文件
                water = new File(darknessWaterImg);
            }else{
                // 装载暗水印文件
                water = new File(lightnessWaterImg);
            }
            // 装入内存
            bufferwater = ImageIO.read(water);
                        
            graphics.drawImage(bufferwater, startX, startY, x, y,
                    null);
            // 水印文件结束
            graphics.dispose();
            FileOutputStream out = new FileOutputStream(targetImg);
            JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
            // 绘制新的文件
            encoder.encode(image);
            out.close();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
        
    /**
     * 查询某个区域的平均灰度
     * @param width
     * @param height
     * @param pixels
     * @return
     */
    private float getAverageGrap(int width,int height,int[] pixels){
        /* 下面是开始算这个区域的亮度了，灰度等同于亮度 */
        ColorModel colorModel = ColorModel.getRGBdefault();
        int i = 0;
        int j = 0;
        int k = 0;
        int r = 0;
        int g = 0;
        int b = 0;
        int gray = 0;
        float average = 0;// 平均灰度
        for (i = 0; i < height; i++) {
            for (j = 0; j < width; j++) {
                // 定位像素点
                k = i * width + j;
                r = colorModel.getRed(pixels[k]);
                g = colorModel.getGreen(pixels[k]);
                b = colorModel.getBlue(pixels[k]);

                // 计算灰度值
                gray = (r * 38 + g * 75 + b * 15) >> 7;

                average = average + gray;
            }
        }
        // 计算平均灰度
        average = average / ((i - 1) * (j - 1));
        return average;
    }
    public static void main(String[] args) {
        WaterMark waterMark = new WaterMark();

        waterMark.pressImage("F:\\Mine\\My Pictures\\素材\\w2.png", "F:\\Mine\\My Pictures\\素材\\w1.png",
                "F:\\Mine\\My Pictures\\素材\\2.jpg", 520, 500, 900, 800, 0.5f, 50);
        System.out.print("添加成功");
    }

}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

<filter>
  <filter-name>jpaFilter</filter-name>
  <filter-class>org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter</filter-class>
</filter>
<filter-mapping>
  <filter-name>jpaFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping> 

<?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:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
    
    <context:annotation-config />
    <context:component-scan base-package="com.xxx.xxx" />
    <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />
    
   	<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <property name="database" value="MYSQL" />
                <property name="showSql" value="true" />
            </bean>
        </property>
    </bean>
    
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost/gmailadmin" />
        <property name="username" value="myweb" />
        <property name="password" value="123456" />
    </bean>
    
    <bean id="transactionManager"
          class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>
    
    <!--声明式事务配置-->
    <aop:config>
        <aop:pointcut id="allServiceOperation" expression="execution(* com.xxx.xxx.service.*Service.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="allServiceOperation"/>
    </aop:config>
    
    <tx:advice id="txAdvice" transaction-manager="transactionManager">   
        <tx:attributes> 
        	<tx:method name="query*" read-only="true" />
            <tx:method name="*" />
        </tx:attributes>
    </tx:advice> 
</beans>

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

HttpClient client = new HttpClient();
HttpMethod method = new GetMethod("http://www.apache.org");
try {
  client.executeMethod(method);
  byte[] responseBody = null;
  
  responseBody = method.getResponseBody();
  
} catch (HttpException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
} catch (IOException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
}finally{
  method.releaseConnection();
  
}

Timeout 30
KeepAlive On   #表示服务器端不会主动关闭链接
MaxKeepAliveRequests 100
KeepAliveTimeout 180 

/**
 * The connection manager created with this constructor will try to keep the 
 * connection open (alive) between consecutive requests if the alwaysClose 
 * parameter is set to <tt>false</tt>. Otherwise the connection manager will 
 * always close connections upon release.
 * 
 * @param alwaysClose if set <tt>true</tt>, the connection manager will always
 *    close connections upon release.
 */
public SimpleHttpConnectionManager(boolean alwaysClose) {
    super();
    this.alwaysClose = alwaysClose;
}

this.httpConnectionManager = new SimpleHttpConnectionManager();

HttpClient client = new HttpClient(new HttpClientParams(),new SimpleHttpConnectionManager(true) );

((SimpleHttpConnectionManager)client.getHttpConnectionManager()).shutdown();

public void shutdown() {
    httpConnection.close();
}

public void closeIdleConnections(long idleTimeout) {
    long maxIdleTime = System.currentTimeMillis() - idleTimeout;
    if (idleStartTime <= maxIdleTime) {
        httpConnection.close();
    }
}

method.setRequestHeader("Connection", "close");

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

希望这篇文章能够对那些正在或即将开发自己团队的J2EE应用快速开发平台（工作流＋代码生成器）的个人或公司能有所启发！    

      像EOS这样动辄几十上百万的平台不是每个公司都愿意花钱去买的！因此构建一套穷人级的企业快速开发平台成了很多团队的首选，而对于小团队来说，构建一套自己可以维护的开发平台才是最重要的。下面，我将以我的平台的开发过程为例来详细解析这个过程！  

“如果能把项目中大量的代码编写工作变得轻松，是多好的一件事!  "

        在使用了AppFuse之后，我有个想法，能不能利用velocity这个优秀的模板引擎，用一种更加直观的模式，把开发项目中的重复代码让它自动生成， 生成之后的基础代码，按照实际的需求稍作修改便可以运行，极大的提高工作效率。这样的话，程序员就可以从大量的重复劳动中解放出来，将精力更多的投入到业 务分析及学习中。

        这个想法一直在我的脑海里横亘不去，尤其在做了大量的重复模块后，深刻体会了重复Coding的那种浪费生命的痛苦后，这种冲动尤为强烈。

         离开旧公司，到了新公司之后，由于职位和公司定位的不同，让我有时间开始把快速开发平台和自动代码生成器的开发真正的摆上开发日程上了。

          第一步 ，自动代码生成器生成 的是业务模块，那么底层必须有一套框架能够为它提供支撑，而且这套基础框架要足够灵活，并且和单个模块的耦合性要比较弱。要解耦模块之间的联系，势必要用 到MVC分层设计。感谢Java的开放性，使它有这么许许多多的MVC框架可以使用。我采用的当然是目前最流行的 SSH（Struts＋Spring＋Hibernate）的组合（以前项目一直在用，也有些成熟的积累），花了三个月的时间，通过一个项目的实际应用来 使这个框架基本成型。其目前功能包括：

        1：灵活完善的权限管理功能（包括用户管理、角色管理、组织机构管理、资源管理、资源角色映射管理...）。原来计划采用开源的JGuard来托管这部分 的功能，因为一些特殊的原因放弃了（考虑要和工作流引擎的权限部分做集成），只采用了其权限管理的一些设计思想。

        2：基于Spring的AOP实现的日志和权限管理（通过Spring的代理也将Struts的Action托管了，使的对Action的调用也能被 AOP侦测到），这样对每个功能的调用，如果需要日志纪录的话，之间将其配置到Spring的配置文件中就可以了。

        3：UI上实现了类似.NET的Validation验证，这点很重要，想必大家都深刻体会到利用JavaScript或Struts的验证机制来实现前端页面数据验证的痛苦了吧：），我们实现的功能如下图所示：

        4、多套UI风格样式。这个不是很必须，但是作为一套成功的系统，良好的用户体验也是必不可少的。

        5、支撑模块：报表引擎（基于JasperReport实现的B/S版本报表），流程引擎（其实就我个人来看，工作流引擎才是这套系统的灵魂 ，有了它，所有流程性应用包括表单、业务流、权限都可以通过配置并结合Beanshell脚本来获得 ，但由于我们集成的是一套反编译重构的商用流程引擎系统，在这里就不再详细描述了 ，呵呵：），有盗版之嫌啊）,以下是我们报表和流程设计器的一些截图：

工作流引擎截图

报表截图

        6、i18n的支持，由于我们有很多国外的客户，这块是必须的。

有了这个基础支撑平台之后，就可以开始着手开放我们的代码生成器了。

        第二步 ：开发代码生成器。 AppFuse基于Ant的自动代码生成模式让我深恶痛绝，究其原因，一句话－－“不够人性化”，我们做的首先必须考虑可用性，因此决定采用可视化的UI 模式。由于我用的是NetBean编辑器，做可视化的Swing开发不成问题（这点要感谢SUN啊，出了个和VB一样简单的IDE）。我实现的代码生成器 的界面如下：

怎么样？是不是够傻瓜化啊？呵呵，是个人都能用啊！

       从上面大家可以看到，我们这个代码生成器和Hibernate的POJO对象生成工具类似，也是基于数据库的模型来生成代码的，不同的是，我们生成的代码 范围更广，不仅包括了POJO对象暨相应的hbm.xml文件，另外还包括相应的DAO（Server层）、相应的Action、Form类、相关的 JSP文件（list页面、edit页面、Excel导出页面等等）、资源文件及相关的Struts和Spring的配置子文件（Struts和 Spring均支撑将配置拆分成多个配置，我们利用这种特性来减低模块之间的耦合性。）

        至于数据库模型的获得，可以利用JDBC的MetaData（元数据模型） 的功能来获得，我们目前维护了表的完整的主键、外键关系（父子表）

 第三步：配置模板。有了可视化的数据库表映射模型，也获得了数据库表及其主外键关系的详细信息，接下来当然是根据这些信息来生成代码了。这里我们用了强大的Velocity模板 技术，这样不仅可以灵活的处理复杂的表映射对象之间的关系，也能够灵活的进行变更升级。而且我们能够通过所获得的数据库模型，在页面上自动实现基于Javascript的数据验证“非空验证、字符长度验证、数字验证，日期验证”。

          呵呵，通过以上3个步骤的工作，我们的基础开发平台和自动代码生成器就大功告成了！目前我们生成的代码可以直接编译通过，通过简单的系统配置后，可以直接在服务器上跑！ 由于模板种类多，而且模板中自动实现的代码功能已经非常完善了，所以一些特殊的业务需求只需要在自动生成的代码基础上做简单修改就可以了！

         基础开发平台和代码生成器投入使用后，对我们项目开发的资源投入的改善是非常明细的，目前基于基础平台和代码生成器的配合，我们已经做了6、7个系统了，平均每个系统的 开发时间至少要比以前节约40％，有的项目甚至达到了80％以上（我们最高的一天，处理了40多个表的增、删、该、查的功能，及中文本地化）。而且，另外 很重要的一点，生成的代码无形中统一了程序员的设计风格，我们通过这套开发机制，能够最大限度的保证我们开发的系统质量，保证模块可以在不同系统之间的自 由迁移，最大限度的实现复用！在项目开发中节省出来的大量时间，也让我们可以去研究更多的开源中间件和系统，来增强我们的基础平台，从而形成一个良性的循 环！

 我们做了多套模板，能够针对单表操作，及父子表操作来自由组合搭配。以下就是我们系统的一些功能截图，除了中文化之外，基本上没有修改：

单表操作：

父子表关联操作：

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

public class Category {
  private Long id;
  private String name; //类别名称

  //Other code omitted
}

public class Product {
  private Long id;
  private String name;       //商品名称
  private Category category; //商品类别
  private Date expDate;      //有效期
  private Float price;       //单价

  //Other code omitted
}

	public List<Product> getProducts(Product product) {
		final Example exampleProduct =
		  Example.create(product).
		    enableLike(MatchMode.ANYWHERE).
                    excludeZeroes();

		return (List<Product>) getHibernateTemplate().execute(
		  new HibernateCallback() {
		    public Object doInHibernate(Session session) throws HibernateException {
		    	Criteria crit =
		    	  session.createCriteria(Product.class).
		    	  add(exampleProduct);
		    	return crit.list();
		    }
		  }
		);
	}

Category category = new Category();
category.setName("xyz");
Product product = new Product();
product.setCategory(category);

List<Product> products = getProducts(product);

//Hibernate的原版Example
//如果属性类型是关联的实体，则忽略
	private boolean isPropertyIncluded(Object value, String name, Type type) {
		return !excludedProperties.contains(name) &&
			!type.isAssociationType() &&
			selector.include(value, name, type);
	}

//改版的AssociationExample
  private boolean includeAssociations = true;

  public boolean isIncludeAssociations()
  {
    return includeAssociations;
  }

  public void setIncludeAssociations(boolean includeAssociations)
  {
    this.includeAssociations = includeAssociations;
  }

//如果属性类型是关联的实体，且该关联是一对一或多对一，且includeAssociations为true，则包括该属性
  private boolean isPropertyIncluded(Object value, String name, Type type) {
    return
      !excludedProperties.contains(name) &&
      selector.include(value, name, type) &&
      (!type.isAssociationType() ||
        (type.isAssociationType() &&
          includeAssociations &&
          !type.isCollectionType()));
  }

//Hibernate原版的Example
  protected void appendPropertyCondition(
    String propertyName,
    Object propertyValue,
    Criteria criteria,
    CriteriaQuery cq,
    StringBuffer buf)
  throws HibernateException {
    Criterion crit;
    if ( propertyValue!=null ) {
//当属性值不为空时，如果是字符串且指定为模糊查询，则使用模糊查询，否则使用等值比较
      boolean isString = propertyValue instanceof String;
      SimpleExpression se = ( isLikeEnabled && isString ) ?
        Restrictions.like(propertyName, propertyValue) :
        Restrictions.eq(propertyName, propertyValue);
      crit = ( isIgnoreCaseEnabled && isString ) ?
        se.ignoreCase() : se;
    }
    else {
      crit = Restrictions.isNull(propertyName);
    }
    String critCondition = crit.toSqlString(criteria, cq);
    if ( buf.length()>1 && critCondition.trim().length()>0 ) buf.append(" and ");
    buf.append(critCondition);
  }


//增强后的EnhancedExample
  private static final RestrictionHolder holder = new DefaultRestrictionHolder();

  /**
   * Restriction strategy definitions
   */
  public static enum RestrictionStrategy {eq, ne, gt, lt, ge, le}

  /**
   * Restriction strategy holder for the query criteria
   */
  public static interface RestrictionHolder {
  	/**
  	 * Set a restriction strategy for a POJO's property
  	 */
    public RestrictionHolder set(String propertyName, RestrictionStrategy strategy);

    /**
     * Get the restriction strategy of the property
     */
    public RestrictionStrategy get(String propertyName);
  }

  static final class DefaultRestrictionHolder implements RestrictionHolder {
		private Map<String, RestrictionStrategy> strategies = new HashMap<String, RestrictionStrategy>();

    public RestrictionHolder set(String propertyName, RestrictionStrategy strategy) {
      strategies.put(propertyName, strategy);
      return this;
    }

    public RestrictionStrategy get(String propertyName) {
      return strategies.get(propertyName);
    }
  }

  /**
   * Get the restriction strategy holder
   */
  public RestrictionHolder getRestrictionHolder() {
    return holder;
  }

  protected void appendPropertyCondition(
    String propertyName,
    Object propertyValue,
    Criteria criteria,
    CriteriaQuery cq,
    StringBuffer buf)
  throws HibernateException {
    Criterion crit;
    if ( propertyValue!=null ) {
//当属性值不为空时，如果为该属性指定了比较条件，则使用指定的比较条件
      RestrictionStrategy strategy = holder.get(propertyName);
      if ( strategy != null ) {
  	switch(strategy) {
    	//case eq: crit = Restrictions.eq(propertyName, propertyValue);
    	case ne: crit = Restrictions.ne(propertyName, propertyValue); break;
    	case gt: crit = Restrictions.gt(propertyName, propertyValue); break;
    	case lt: crit = Restrictions.lt(propertyName, propertyValue); break;
    	case ge: crit = Restrictions.ge(propertyName, propertyValue); break;
    	case le: crit = Restrictions.le(propertyName, propertyValue); break;
    	default: crit = Restrictions.eq(propertyName, propertyValue);
        };
      }
      else {
//否则使用默认的比较条件：如果是字符串且指定为模糊查询，则使用模糊查询，否则使用等值比较
	boolean isString = propertyValue instanceof String;
	SimpleExpression se = ( isLikeEnabled && isString ) ?
	  Restrictions.like(propertyName, propertyValue) :
	  Restrictions.eq(propertyName, propertyValue);
	crit = ( isIgnoreCaseEnabled && isString ) ?
	  se.ignoreCase() : se;
      }
    }
    else {
      crit = Restrictions.isNull(propertyName);
    }
    String critCondition = crit.toSqlString(criteria, cq);
    if ( buf.length()>1 && critCondition.trim().length()>0 ) buf.append(" and ");
    buf.append(critCondition);
  }

	public List<Product> getProducts(Product product) {
		//改用EnhancedExample来允许关联对象的条件查询
		final EnhancedExample exampleProduct =
		  EnhancedExample.create(product).
		    enableLike(MatchMode.ANYWHERE).
                    excludeZeroes();
		  //指定expDate属性使用大于等于比较方法
		exampleProduct.getRestrictionHolder().
		  set("expDate", EnhancedExample.RestrictionStrategy.ge);

		return (List<Product>) getHibernateTemplate().execute(
		  new HibernateCallback() {
		    public Object doInHibernate(Session session) throws HibernateException {
		    	Criteria crit =
		    	  session.createCriteria(Product.class).
		    	  add(exampleProduct);
		    	return crit.list();
		    }
		  }
		);
	}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

由于工作的原因，接触了SDO，在研发的过程中遇到很多类型转换方面的问题，网上相应的中文资料比较少，自己总结了一些tip，希望对大家有所帮助

将一个DataObject赋予另一个同schema生成的DataObject时，报

Exception in thread "main" java.lang.ClassCastException: The feature 'ReceiveOrder's type 
'ReceiveOrder' does not permit a 
value of type 'ReceiveOrder'
	at org.eclipse.emf.ecore.impl.EStructuralFeatureImpl$BasicFeatureMapEntry.
validate(EStructuralFeatureImpl.java:2843)
	at org.eclipse.emf.ecore.util.FeatureMapUtil.createEntry(FeatureMapUtil.java:146)
	at org.eclipse.emf.ecore.util.BasicFeatureMap.createEntry(BasicFeatureMap.java:94)
	at org.eclipse.emf.ecore.util.BasicFeatureMap.set(BasicFeatureMap.java:1051)
	at org.eclipse.emf.ecore.util.FeatureMapUtil$FeatureValue.set(FeatureMapUtil.java:1149)
	at org.eclipse.emf.ecore.impl.EStructuralFeatureImpl$InternalSettingDelegateFeatureMapDelegator
.dynamicSet(EStructuralFeatureImpl.java:1401)
	at org.eclipse.emf.ecore.impl.BasicEObjectImpl.eDynamicSet(BasicEObjectImpl.java:709)
	at org.apache.tuscany.sdo.impl.DynamicDataObjectImpl.eDynamicSet(DynamicDataObjectImpl.java:160)
	at org.apache.tuscany.sdo.impl.DataObjectImpl.eSet(DataObjectImpl.java:1476)
	at org.eclipse.emf.ecore.impl.BasicEObjectImpl.eSet(BasicEObjectImpl.java:654)
	at org.apache.tuscany.sdo.helper.XMLDocumentImpl.save(XMLDocumentImpl.java:204)
	at org.apache.tuscany.sdo.helper.XMLDocumentImpl.save(XMLDocumentImpl.java:160)
	at org.apache.tuscany.sdo.helper.XMLDocumentImpl.save(XMLDocumentImpl.java:167)
	at org.apache.tuscany.sdo.helper.XMLHelperImpl.save(XMLHelperImpl.java:168)
	at org.apache.tuscany.sdo.helper.XMLHelperImpl.save(XMLHelperImpl.java:130)

 我们看下试验的代码：

//从字符串创造DataObject
                String dataObjectStr = 
			 "<m:ReceiveOrder xmlns:m=\"http://ordertomanufacturingservice.services.starflow.ro.icss.com/wsdl\">" +
			       "<orderId>testreciiveServcice11111</orderId>" +
			       "<customerId>String</customerId>" +
			       "<customerName>String</customerName>" +
			       "<orderItems>" +
			          "<orderItem>	" +
			             "<productName>String</productName>" +
			             "<price>3.1415926535897932384626433832795</price>" +
			             "<quantity>String</quantity>" +
			             "<comment>String</comment>" +
			             "<shipDate>String</shipDate>	" +
			           "</orderItem>" +
			        "</orderItems>" +
			  "</m:ReceiveOrder>";

                //创造第一个DataObject
		 HelperContext scope =  SDOUtil.createHelperContext();
		 loadTypesFromXMLSchemaStr(scope,schema3);
		 XMLDocument xmlDoc = getXMLDocumentFromString(scope,dataObjectStr);
		 DataObject root = xmlDoc.getRootObject();
		 
		//创造第二个DataObject
		 HelperContext scope2 =  SDOUtil.createHelperContext();
		 DataObject obj = createRootDataObject(scope2,schema3,"ReceiveOrder");
		 
		 //将第一个DO赋予第二个DO
		 obj = root;
		 String xmlstr = scope2.getXMLHelper().save(obj, getNameSpaceFromSchema(schema3), 
                      "ReceiveOrder");
		 System.out.println(xmlstr);

              /**
	        * 从字符串中获取XMLDocument对象
	        * @param scope
	        * @param xmlDoc
	        * @return
	        * @throws IOException
	        */
               private static XMLDocument getXMLDocumentFromString(HelperContext scope, 
                        String xmlDoc) throws IOException {
		InputStream is = new ByteArrayInputStream(xmlDoc.getBytes());
		XMLDocument result = scope.getXMLHelper().load(is);
		return result;
	       }

            /**
	      * 创建文档的顶层DO
	      * @param schemaStr
	      * @param type
	      * @return
	      * @throws UnsupportedEncodingException
	      * @throws FileNotFoundException
	      */
             private static DataObject createRootDataObject(HelperContext scope,String schemaStr
                    ,String type) throws UnsupportedEncodingException, FileNotFoundException{
		loadTypesFromXMLSchemaStr(scope,schemaStr);
		DataFactory factory = scope.getDataFactory();         
		DataObject root = factory.create(getNameSpaceFromSchema(schemaStr),type);
		return root;
	      }
                

 打印结果如下：

Exception in thread "main" java.lang.ClassCastException: The feature 'ReceiveOrder's type
 'ReceiveOrder' does not permit a value of type 'ReceiveOrder'
	at org.eclipse.emf.ecore.impl.EStructuralFeatureImpl$BasicFeatureMapEntry
.validate(EStructuralFeatureImpl.java:2843)
	at org.eclipse.emf.ecore.util.FeatureMapUtil.createEntry(FeatureMapUtil.java:146)
	at org.eclipse.emf.ecore.util.BasicFeatureMap.createEntry(BasicFeatureMap.java:94)
	at org.eclipse.emf.ecore.util.BasicFeatureMap.set(BasicFeatureMap.java:1051)
	at org.eclipse.emf.ecore.util.FeatureMapUtil$FeatureValue.set(FeatureMapUtil.java:1149)
	at org.eclipse.emf.ecore.impl.EStructuralFeatureImpl$InternalSettingDelegateFeatureMapDelegator
.dynamicSet(EStructuralFeatureImpl.java:1401)
	at org.eclipse.emf.ecore.impl.BasicEObjectImpl.eDynamicSet(BasicEObjectImpl.java:709)
	at org.apache.tuscany.sdo.impl.DynamicDataObjectImpl.eDynamicSet(DynamicDataObjectImpl.java:160)
	at org.apache.tuscany.sdo.impl.DataObjectImpl.eSet(DataObjectImpl.java:1476)
	at org.eclipse.emf.ecore.impl.BasicEObjectImpl.eSet(BasicEObjectImpl.java:654)
	at org.apache.tuscany.sdo.helper.XMLDocumentImpl.save(XMLDocumentImpl.java:204)
	at org.apache.tuscany.sdo.helper.XMLDocumentImpl.save(XMLDocumentImpl.java:160)
	at org.apache.tuscany.sdo.helper.XMLDocumentImpl.save(XMLDocumentImpl.java:167)
	at org.apache.tuscany.sdo.helper.XMLHelperImpl.save(XMLHelperImpl.java:168)
	at org.apache.tuscany.sdo.helper.XMLHelperImpl.save(XMLHelperImpl.java:130)
	at com.icss.ro.starflow.service.mappingservice.Test2.main(Test2.java:305)

这就奇怪了，我明明用同样的schema创建的两个对象，按照java中最基本的赋值原则，我这样直接给DO赋值也应该没错啊，百思不得其解。仔细观察发现，两个DO虽然属于同一个schema，但隶属于不同的HelperContext,问题会不会出在这里呢，我们再试验下，代码修改为：

               //创造第一个DataObject
		 HelperContext scope =  SDOUtil.createHelperContext();
		 loadTypesFromXMLSchemaStr(scope,schema3);
		 XMLDocument xmlDoc = getXMLDocumentFromString(scope,dataObjectStr);
		 DataObject root = xmlDoc.getRootObject();
		 
		//创造第二个DataObject
		 HelperContext scope2 =  SDOUtil.createHelperContext();
		 DataObject obj = createRootDataObject(scope,schema3,"ReceiveOrder");
		 
		 //将第一个DO赋予第二个DO
		 obj = root;
		 String xmlstr = scope.getXMLHelper().save(obj, getNameSpaceFromSchema(schema3), 
                      "ReceiveOrder");
		 System.out.println(xmlstr);

这时的打印结果为：

<?xml version="1.0" encoding="UTF-8"?>
<tns:ReceiveOrder xmlns:tns="http://ordertomanufacturingservice.services.starflow.ro.icss.com/wsdl">
  <orderId>testreciiveServcice11111</orderId>
  <customerId>String</customerId>
  <customerName>String</customerName>
  <orderItems>
    <orderItem>
      <productName>String</productName>
      <price>3.1415926535897932384626433832795</price>
      <quantity>String</quantity>
      <comment>String</comment>
      <shipDate>String</shipDate>
    </orderItem>
  </orderItems>
</tns:ReceiveOrder>

通过这个例子，我们发现，如果要给两个DO赋值的话，它不单要隶属于同一个xsd文件的同一个类型，而且还要隶属同一个HelperConetxt,否则就要报如上的异常了。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

目标：使用一些材料，在一座城市打造出一把武器

包含元素：

      一、锻造材料：

                1、 源生材料:  源生火焰   源生空气   源生法力    源生之土

                2、 矿石：      氪金锭       恒金锭  

                3、 药水：      超级活力药水      魔能法力药水

      二、锻造成品：

                1、 双手锤：   雷霆        

                2、 单手锤：   龙拳之锤          

      二、锻造地点：

                1、奥格瑞玛 

                2、暴风城

                3、沙塔斯

主要逻辑：1、锻造一把武器需要不同数量的材料：雷霆需要3种材料（源生材料、矿石、药水）

                                                                     龙拳之锤需要2种材料（源生材料、矿石）

                2、不同城市锻造武器需要的材料不同：例如：奥格瑞玛(氪金、原生空气、超级活力药水)

                                                                                 沙塔斯(恒金、原生之火、魔能法力药水)

                3、运用抽象工厂模式和工厂方法模式

主要代码：

/*  
 * 抽象工厂接口，负责创建原材料  
 * 运用抽象工厂模式  
 * 原材料包括 矿石类：Ore  
 *          源生类：Primal  
 *          药水类：Potion  
 */  
public interface CityIngredientFactory {   
    public Primal createPrimal();   
    public Ore createOre();   
    public Potion createPotion();   
}  

/*  
 * 实现抽象材料工厂  
 * 在暴风城锻造城所需要的材料  
 * 氪金　+　原生之火 +　超级活力药水  
 */  
public class CityStormwindFactory implements CityIngredientFactory {   
    //氪金   
    public Ore createOre() {   
        return new OreKrypton();   
    }   
    //原生之火   
    public Primal createPrimal() {   
        return new PrimalMana();   
    }   
    //超级活力药水   
    public Potion createPotion() {   
        return new PotionRed();   
    }   
}  

/*  
 * 实现抽象材料工厂  
 * 在沙塔斯锻造城所需要的材料  
 */  
public class CityShattrathFactory implements CityIngredientFactory {   
    //恒金   
    public Ore createOre() {   
        return new OreEternium();   
    }   
    //原生之火   
    public Primal createPrimal() {   
        return new PrimalFire();   
    }   
    //魔能法力药水   
    public Potion createPotion() {   
        return new PotionGreen();   
    }   
}  

/*  
 * 实现抽象材料工厂  
 * 在奥格瑞玛锻造所需要的材料  
 */  
public class CityOrgrimmarFactory implements CityIngredientFactory {   
    //氪金   
    public Ore createOre() {   
        return new OreKrypton();   
    }   
    //原生空气   
    public Primal createPrimal() {   
        return new PrimalAir();   
    }   
    //超级活力药水   
    public Potion createPotion() {   
        return new PotionRed();   
    }   
  
}  

以上工厂类已经就绪。

下面开始写武器类

/*  
 * 工厂类已经就绪，准备武器用到的材料  
 * 要锻造的武器的抽象基类  
 */  
public abstract class Weapon {   
    protected String weaponName;   
    //制作武器将用到的原料   
    protected Ore ore;   
    protected Primal primal;   
    protected Potion potion;   
    //抽象方法用来收集来自“材料工厂”的材料，在子类中实现   
    public abstract void prepare();   
       
    public void makeUp()   
    {   
        System.out.println("==========准备锻造==========");   
    }   
  
    public void make()   
    {   
        System.out.println("==========开始锻造==========");   
        System.out.println("放入材料：");   
        System.out.println("         " + ore.toString());      
        System.out.println("         " + primal.toString());   
        if(null!=potion){   
            System.out.println("         " + potion.toString());   
        }   
    }   
    public void makeEnd()   
    {   
        System.out.println("锻造成品：");   
        System.out.println("         " + this.getWeaponName());    
        System.out.println("==========锻造结束==========");   
    }   
  
    public String getWeaponName() {   
        return weaponName;   
    }   
  
    public void setWeaponName(String weaponName) {   
        this.weaponName = weaponName;   
    }   
       
       
}  

/*  
 * 继承自武器的抽象基类  
 * 锻造-龙拳之锤-  
 */  
public class WeaponDragon extends Weapon{   
    CityIngredientFactory cityIngredientFactory;   
    //构造函数中取得一个工厂并储存到一个实例变量中   
    public WeaponDragon(CityIngredientFactory cityIngredientFactory)   
    {   
        this.cityIngredientFactory = cityIngredientFactory;    
    }   
    //覆盖父类方法，获得“材料工厂”的对应的材料对象   
    @Override  
    public void prepare() {   
        //从材料工厂得到正确的材料   
        //龙拳之锤需要2种材料   
        this.ore = cityIngredientFactory.createOre();   
        this.primal = cityIngredientFactory.createPrimal();   
        this.weaponName = "龙拳之锤";   
    }   
}  

/*  
 * 继承自武器的抽象基类  
 * 锻造-雷霆-  
 */  
public class WeaponWrath extends Weapon {   
    CityIngredientFactory cityIngredientFactory;   
    //构造函数中取得一个工厂并储存到一个实例变量中   
    public WeaponWrath(CityIngredientFactory cityIngredientFactory)   
    {   
        this.cityIngredientFactory = cityIngredientFactory;    
    }   
  
    @Override  
    public void prepare() {   
        //从材料工厂得到正确的材料   
        //雷霆需要3种材料   
        this.ore = cityIngredientFactory.createOre();   
        this.primal = cityIngredientFactory.createPrimal();   
        this.potion =  cityIngredientFactory.createPotion();   
        this.weaponName = "雷霆";   
    }   
  
}  

下面开始打造武器。
在不同的城市、打造需要的材料不同

/*  
 * 抽象基类  
 */  
public abstract class ForgeWeapon {   
    //武器的实例   
    Weapon weapon;   
    public void forgeWeaponNow(String weaponType)   
    {   
        weapon = createforgeWeapon(weaponType);   
        weapon.prepare();   
        //锻造步骤   
        weapon.makeUp();   
        weapon.make();   
        weapon.makeEnd();   
    }   
    /*  
     * 实例化在子类进行 运用了工厂方法模式  
     */  
    protected abstract Weapon createforgeWeapon(String city);   
}  

/*  
 * 奥瑞格玛锻造  
 */  
public class OrgrimmarForgeWeapom extends ForgeWeapon {   
    @Override  
    protected Weapon createforgeWeapon(String type) {   
        Weapon weapon;   
        //因为是在奥瑞格玛锻造，所以实例化一个奥瑞格玛的材料工厂   
        CityIngredientFactory cityIngredientFactory = new CityOrgrimmarFactory();   
        System.out.println("==============您在奥格瑞玛锻造============");   
        //根据传入参数判断锻造哪种武器   
        if(type == "Dragon" || "Dragon".equals(type))   
        {   
            weapon = new WeaponDragon(cityIngredientFactory);   
               
            return weapon;   
        }   
        else if(type == "Wrath" || "Wrath".equals(type))   
        {   
            weapon = new WeaponWrath(cityIngredientFactory);   
            return weapon;   
        }   
        return null;   
    }   
}  

/*  
 * 沙塔斯城锻造  
 */  
public class ShattrathForgeWeapom extends ForgeWeapon {   
    @Override  
    protected Weapon createforgeWeapon(String type) {   
        Weapon weapon;   
        //因为是在沙塔斯城锻造，所以实例化一个沙塔斯城的材料工厂   
        CityIngredientFactory cityIngredientFactory = new CityShattrathFactory();   
        System.out.println("==============您在沙塔斯城锻造============");   
        //根据传入参数判断锻造哪种武器   
        if(type == "Dragon" || "Dragon".equals(type))   
        {   
            weapon = new WeaponDragon(cityIngredientFactory);   
               
            return weapon;   
        }   
        else if(type == "Wrath" || "Wrath".equals(type))   
        {   
            weapon = new WeaponWrath(cityIngredientFactory);   
            return weapon;   
        }   
        return null;   
    }   
       
}  

/*  
 * 暴风城锻造  
 */  
public class StormwindForgeWeapom extends ForgeWeapon {   
       
    @Override  
    protected Weapon createforgeWeapon(String type) {   
        Weapon weapon;   
        //因为是在暴风城锻造，所以实例化一个暴风城的材料工厂   
        CityIngredientFactory cityIngredientFactory = new CityStormwindFactory();   
        System.out.println("==============您在暴风城锻造============");   
        //根据传入参数判断锻造哪种武器   
        if(type == "Dragon" || "Dragon".equals(type))   
        {   
            weapon = new WeaponDragon(cityIngredientFactory);   
               
            return weapon;   
        }   
        else if(type == "Wrath" || "Wrath".equals(type))   
        {   
            weapon = new WeaponWrath(cityIngredientFactory);   
            return weapon;   
        }   
        return null;   
    }   
       
}  

 测试类:

/*  
 * 锻造武器测试类  
 */  
public class makeWeaponTest extends TestCase {   
    ForgeWeapon forgeWeapon1;   
    ForgeWeapon forgeWeapon2;   
    ForgeWeapon forgeWeapon3;      
    ForgeWeapon forgeWeapon4;   
    //初始化   
    @Override  
    protected void setUp() throws Exception {      
        forgeWeapon1 = new OrgrimmarForgeWeapom();   
        forgeWeapon2 = new ShattrathForgeWeapom();   
        forgeWeapon3 = new ShattrathForgeWeapom();   
        forgeWeapon4 = new StormwindForgeWeapom();   
        System.out.println("*********测试开始*********");                  
    }   
       
    @Override  
    protected void tearDown() throws Exception {   
        System.out.println("*********测试结束*********\n");   
    }   
       
    public  void testforgeWeapon1()   
    {   
        System.out.println("测试1:奥格瑞玛锻造 龙拳之锤");   
        forgeWeapon1.forgeWeaponNow("Dragon");   
    }   
  
    public  void testforgeWeapon2()   
    {   
        System.out.println("测试2:沙塔斯城锻造 龙拳之锤");   
        forgeWeapon2.forgeWeaponNow("Dragon");   
    }   
       
    public  void testforgeWeapon3()   
    {   
        System.out.println("测试3:沙塔斯城锻造 雷霆");   
        forgeWeapon3.forgeWeaponNow("Wrath");   
    }   
       
    public  void testforgeWeapon4()   
    {   
        System.out.println("测试4:暴风城锻造 雷霆");   
        forgeWeapon4.forgeWeaponNow("Wrath");   
    }   
}  

 
测试打印:

*********测试开始*********   
测试1:奥格瑞玛锻造 龙拳之锤   
==============您在奥格瑞玛锻造============   
==========准备锻造==========   
==========开始锻造==========   
放入材料：   
         氪金   
         源生空气   
锻造成品：   
         龙拳之锤   
==========锻造结束==========   
*********测试结束*********   
  
*********测试开始*********   
测试2:沙塔斯城锻造 龙拳之锤   
==============您在沙塔斯城锻造============   
==========准备锻造==========   
==========开始锻造==========   
放入材料：   
         恒金   
         源生火焰   
锻造成品：   
         龙拳之锤   
==========锻造结束==========   
*********测试结束*********   
  
*********测试开始*********   
测试3:沙塔斯城锻造 雷霆   
==============您在沙塔斯城锻造============   
==========准备锻造==========   
==========开始锻造==========   
放入材料：   
         恒金   
         源生火焰   
         魔能法力药水   
锻造成品：   
         雷霆   
==========锻造结束==========   
*********测试结束*********   
  
*********测试开始*********   
测试4:暴风城锻造 雷霆   
==============您在暴风城锻造============   
==========准备锻造==========   
==========开始锻造==========   
放入材料：   
         氪金   
         源生法力   
         超级活力药水   
锻造成品：   
         雷霆   
==========锻造结束==========   
*********测试结束********* 

知识点：

工厂方法模式：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个，工厂方法让类把实例化推迟到子类。

抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。（抽象工厂允许客户使用抽象的接口来创建一组相关的产品，而不需要知道或关心实际产出的具体产品是什么，这样一来，客户就从具体的产品被解耦）

水平有限差错在所难免 欢迎提出问题

本文注重的是设计模式的运用，不是探讨游戏开发，请读者注意主题

代码下载在http://everlive.javaeye.com/blog/233138

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

1、java设置内存的参数是否合适
2、查询数据库，遇到比较大的数据集，或者sql写的效率比较低
3、java处理文件的时候，如果文件比较大。

我只想到这3中情况，系统那位能够继续补充。

想要更多的人帮助你，请先帮助更多的人～～～

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

简介

实战一 , 实战二 介绍了ActiveMQ的基本概念和配置方式.

本篇将通过一个实例介绍使用spring发送,消费topic, queue类型消息的方法. 不懂topic和queue的google 之.

如图示, TOPIC和QUEUE分别代表一个topic和一个queue消息通道.

1. TopicMessageProducer向topic发送消息, TopicConsumerA和TopicConsumerB则从topic消费消息.
2. QueueMessageProducer向Queue发送消息, QueueConsumer从Queue中消费消息

Spring整合JMS

就像对orm, web的支持一样, spring同样支持jms, 为整合jms到已有的项目提供了很多便利的方法. 本篇主要讲实战, 是所以先从配置开始, spring配置jms基本上需要8个部分.

1. ConnectionFactory. 和jms服务器的连接, 可以是外部的jms server, 也可以使用embedded ActiveMQ Broker.
2. Destination. 有topic和queue两种方式.
3. JmsTemplate. spring提供的jms模板.
4. MessageConverter. 消息转换器.
5. MessageProducer. 消息生产者.
6. MessageConsumer. 消息消费者.
7. MessageListener. 消息监听器
8. MessageListenerContainer. 消息监听容器

下面以实例的方式介绍上面8个部分.

1. ConnectionFactory

<amq:connectionFactory id="jmsConnectionFactory" brokerURL="vm://localhost" />

 brokerURL是指要连接的activeMQ server的地址, activeMQ提供了多种brokerURL, 集体可参见文档.一般我们使用嵌套的ActiveMQ server. 配置如下, 这个配置使用消息的存储机制, 服务器重启也不会丢失消息.

<!--  embedded ActiveMQ Broker -->
	<amq:broker useJmx="false" persistent="true">
		<amq:persistenceAdapter>
			<amq:amqPersistenceAdapter directory="d:/amq"/>
		</amq:persistenceAdapter>
		<amq:transportConnectors>
			<amq:transportConnector uri="tcp://localhost:0" />
		</amq:transportConnectors>
	</amq:broker>

 2. Destination

 在实例中我们使用了两种destination

<!--  ActiveMQ destinations  -->
<!--  使用topic方式-->
<amq:topic name="TOPIC" physicalName="JMS-TEST-TOPIC" />
<!--  使用Queue方式-->
<amq:queue name="QUEUE" physicalName="JMS-TEST-QUEUE" />

 3. JmsTemplate

<!--  Spring JmsTemplate config -->
	<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
		<property name="connectionFactory">
			<!--  lets wrap in a pool to avoid creating a connection per send -->
			<bean class="org.springframework.jms.connection.SingleConnectionFactory">
				<property name="targetConnectionFactory" ref="jmsConnectionFactory" />
			</bean>
		</property>
		<!-- custom MessageConverter -->
		<property name="messageConverter" ref="defaultMessageConverter" />
	</bean>

  4. MessageConverter

   MessageConverter实现的是org.springframework.jms.support.converter.MessageConverter接口, 提供消息的转换功能. DefaultMessageConverter的实现见附件.

<bean id="defaultMessageConverter" class="com.andyao.activemq.DefaultMessageConverter" />

  5. MessageProducer

   实例拥有两个消息生产者, 消息生产者都是POJO, 实现见附件.

<!-- POJO which send Message uses  Spring JmsTemplate -->
	<bean id="topicMessageProducer" class="com.andyao.activemq.TopicMessageProducer">
		<property name="template" ref="jmsTemplate" />
		<property name="destination" ref="TOPIC" />
	</bean>
	<bean id="queueMessageProducer" class="com.andyao.activemq.QueuMessageProducer">
		<property name="template" ref="jmsTemplate" />
		<property name="destination" ref="QUEUE" />
	</bean>

 6. MessageConsumer

 TOPIC通道有两个消息消费者, QUEUE有一个消息消费者

<!--  Message Driven POJO (MDP) -->
    <!-- consumer1 for topic a -->
    <bean id="topicConsumerA" class="com.andyao.activemq.TopicConsumerA" />
    <!-- consumer2 for topic a -->
    <bean id="topicConsumerB" class="com.andyao.activemq.TopicConsumerB" />
    <!-- consumer for queue -->
    <bean id="queueConsumer" class="com.andyao.activemq.QueueConsumer" />

  7. MessageListener

每一个消息消费者都对应一个MessageListener

<bean id="topicListenerA" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
		<constructor-arg ref="topicConsumerA" />
		<!--  may be other method -->
		<property name="defaultListenerMethod" value="receive" />
		<!-- custom MessageConverter define -->
		<property name="messageConverter" ref="defaultMessageConverter" />
	</bean>

	<bean id="topicListenerB" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
		<constructor-arg ref="topicConsumerB" />
		<!--  may be other method -->
		<property name="defaultListenerMethod" value="receive" />
		<!-- custom MessageConverter define -->
		<property name="messageConverter" ref="defaultMessageConverter" />
	</bean>

    <bean id="queueListener" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
		<constructor-arg ref="queueConsumer" />
		<!--  may be other method -->
		<property name="defaultListenerMethod" value="receive" />
		<!-- custom MessageConverter define -->
		<property name="messageConverter" ref="defaultMessageConverter" />
	</bean>

 8. MessageListenerContainer

 有几个MessageListener既有几个MessageListenerContainer

<bean id="topicListenerContainerA" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="jmsConnectionFactory" />
		<property name="destination" ref="TOPIC" />
		<property name="messageListener" ref="topicListenerA" />
	</bean>

    <bean id="topicListenerContainerB" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="jmsConnectionFactory" />
		<property name="destination" ref="TOPIC" />
		<property name="messageListener" ref="topicListenerB" />
	</bean>
    
    <bean id="queueListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="jmsConnectionFactory" />
		<property name="destination" ref="QUEUE" />
		<property name="messageListener" ref="queu