Java论坛最新讨论 - JavaEye

IOC?真的IOC了？还是Factory?

JavaEye网站 — Mon, 13 Oct 2008 15:08:41 +0800

作者: yananay 链接：http://www.javaeye.com/topic/252235 发表时间: 2008年10月13日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

在google上搜索 “spring ioc”，会出来一堆堆的搜索结果，随便点哪一个进去，都会看到这样的教程：

ClassA a = (ClassA) beanFactory.getBean("A");

ok, 教程中都说这是Spring的ioc用法， ClassA 是被 Spring管理的，ClassA中的需要set的变量都是“自动注入”的，例如：

public class ClassA {
  private ClassB b;
  public void setB(ClassB b) {
    this.b = b;
  }
}

所有的教程，文档，甚至Spring的文档，都说这是 IOC。

但是很少有人提及这一点：beanFactory.getBean("A") 是一个工厂模式。

前一阵经过梁兄的指点，俺才发现：这明明就是工厂模式呀！也就是说你要使用 IOC，前提是要使用工厂模式。虽然 ClassA 是被自动装配的，但那之前，你必须使用工厂模式来得到装配后的 ClassA。

换个比喻来说：如果你要使用一个手枪，必须先用火柴去点燃手枪里的火药。

不晓得大家对这个问题怎么个看法，至少俺觉得有些别扭，其实我们完全可以不使用工厂模式。考虑下面这个类：

public class StandardConfiguration {

	private static Logger logger = Logger.getLogger(StandardConfiguration.class);
	
	private ImportBusiness importBusiness;
	
	public StandardConfiguration(BeanFactory beanFactory) {
		
		Method[] methods = getClass().getMethods();
		
		for(Method method : methods) {
			
			String methodName = method.getName();
			Class returnType = method.getReturnType();
			if(methodName.startsWith("get")) {
				
				String fieldName = getFieldName(methodName);
				
				Object bean = null;
				try {
					bean = beanFactory.getBean(fieldName);
					
				} catch (NoSuchBeanDefinitionException e) {
					
					logger.debug("StandardConfiguration - " + fieldName + " NoSuchBeanDefinitionException, ignore.");
					continue;
				}
				
				String setMethodName = "set" + createFieldMethodVar(fieldName);
				
				Method setMethod = null;
				try {
					setMethod = getClass().getMethod(setMethodName, new Class[]{returnType});
					setMethod.invoke(this, bean);
					
				} catch (NoSuchMethodException e) {
					
					logger.debug("StandardConfiguration - " + fieldName + " has no set method.");
					
				} catch (InvocationTargetException e) {
					
					logger.error("StandardConfiguration - " + fieldName + " invoke failed.");
				} catch (IllegalAccessException e) {
					
					logger.error("StandardConfiguration - " + fieldName + " IllegalAccessException.");
				}
			}
		}
		
	}
	
	private String getFieldName(String methodName) {
		
		String fieldName = methodName.substring(3, methodName.length());
		fieldName = fieldName.substring(0, 1).toLowerCase() +
						fieldName.substring(1, fieldName.length());
		
		return fieldName;
	}
	
	private String createFieldMethodVar(String fieldName) {
		
		return fieldName.substring(0, 1).toUpperCase() +
				fieldName.substring(1, fieldName.length());
	}

	public ImportBusiness getImportBusiness() {
		return importBusiness;
	}

	public void setImportBusiness(ImportBusiness business) {
		this.importBusiness = business;
	}
}

这个类按照下面的方式来使用：

StandardConfiguration config = new StandardConfiguration(beanFactory)
ImportBusiness importBusiness = config.getImportBusiness();

其中 beanFactory 是 Spring 中的 BeanFactory，ImportBusiness 是一个普通的类。

ok，我们避免了 beanFactory.getBean("A") 的用法，我可以说：当我 new 一个 StandardConfiguration 的时候，里面的变量都是自动注入的。

但是有人说：你这是穿裤子放屁--你不是还得使用 BeanFactory？

没错，没错，这也是我想说的主要话题之一，如果 BeanFactory 能修改一下该多好！

我设想的情况是这样使用：

public class StandardConfiguration extends BeanFactory {
  private ImportBusiness importBusiness;
  public ImportBusiness getImportBusiness() {
    return importBusiness;
  }

  public void setImportBusiness(ImportBusiness business) {
     this.importBusiness = business;
  }
}

这样当我 new 一个 StandardConfiguration 的时候，里面的变量就自动装配起来。这样的话，BeanFactory 似乎应该叫 BeanConfiguration 更好了。

通过这样的方式，我们完全可以避免工厂模式的出现。这样做有什么好处呢：
1、避免了工厂模式的使用，单一的IOC更加简单。
2、避免了通过 bean name（beanFactory.getBean("A");）来获得某一个对象。其实也就是避免了hardcode。

已有 6 人发表回复，猛击->>这里<<-参与讨论

JavaEye推荐

SPRING的AOP不适合多线程应用？

JavaEye网站 — Sun, 12 Oct 2008 21:51:39 +0800

作者: 大猫汤姆链接：http://www.javaeye.com/topic/251923 发表时间: 2008年10月12日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

如题，
我的理解是：AOP代理对像实例化所花费的开销比较大，而且是非线程安全的，
所以线程安全的解决办法：
方法一：使用时要么每次都NEW一个，这样的用一次就扔掉我认为是对资源的浪费。
方法二：在应用中适当的地方加同步进行排队。这样虽然减小了开消，但是对线程高并发的情况肯定是个瓶颈。
我目前对SPRING的观点是：
SPRING是一种解决问题的办法,方案，一种思想。

IOC 只有IOC是个很不错的东西。但是如果不使用AOP的话IOC好像没什么价值，只是换个角度去解决问题。

AOP 如果不在乎机器资源的开消问题才可以使用，以灵活性换取性能。小型应用没必要使用，流量大的门户网站不能使用。

MVC 愿意用就用。

对HIBERNATE，JDBC，MAIL的封装等我认为没有必要，完全可以自己来实现，这样更清楚，更容易撑握应用程序。看到SPRING把这些东西包裹起来从心底感到恶心。比如封装HIBERNATE时，获取Session里用到的threadLocal，这东西被封装了起来，客户端程序员想用的时候只能新创建一个,THREADLOCAL对性能是有一定的影响的(虽然JDK1.5已经很好的优化了)，一个就够了。

感觉SPRING就是狗皮膏药，做救急的东西，在不修改源代码的情况下拦腰插入一些代码，因为实际上线的应用程序中大家都不敢修改源代码，修改源代码非常危险麻烦,整个应用还需要反复测试，所以用AOP来支撑。

已有 6 人发表回复，猛击->>这里<<-参与讨论

JavaEye推荐

servlet成功连接sql2000

JavaEye网站 — Tue, 14 Oct 2008 00:19:22 +0800

作者: collonn 链接：http://www.javaeye.com/topic/252431 发表时间: 2008年10月14日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1：

一定要为sql2000打上 SQL2KSP4 补丁，否则的话，不用往下看了

2：

下载sql2000需要的三个驱动文件 msSQL2000JDBC ，将解压后的三个文件msbase.jar，mssqlserver.jar，

msutil.jar拷贝到WEB-INF/lib文件夹下，记得刷新喔

3：

创建一个测试用数据库siaswushu，新建表userinfo(name,pwd)

4：

sql2000要启用"混合验证模式"

5：编写测试用servlet，代码如下

package collon;

import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class ConnSql extends HttpServlet {

public ConnSql() {
super();
}

public void destroy() {
super.destroy(); // Just puts "destroy" string in log
// Put your code here
}

public void doGet(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {

  response.setCharacterEncoding("GBK");

  response.setContentType("text/html");
  PrintWriter out = response.getWriter();
  out.println("");
  out.println("");
  out.println(" A Servlet");
  out.println(" ");
  out.print("所有用户的信息为
");

  Connection conn = null;
  Statement stm = null;
  ResultSet rs = null;
  String connStr = "jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=siaswushu";

  try{
   Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");

  }catch(ClassNotFoundException e){
   e.printStackTrace();
  }

  try {
   conn = DriverManager.getConnection(connStr,"sa","sa");
   stm = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_READ_ONLY);
   rs = stm.executeQuery("select * from userinfo");

   while(rs.next()){
    out.print("用户名: " + rs.getString("name") + "------密码: " + rs.getString("pwd") + "
");
   }

   rs.close();
   stm.close();
   conn.close();
  } catch (SQLException e) {
   // TODO 自动生成 catch 块
   e.printStackTrace();
  }

  out.println(" ");
  out.println("");
  out.flush();
  out.close();
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  this.doGet(request, response);
}

public void init() throws ServletException {
// Put your code here
}

}

注意：

ResultSet.TYPE_FORWORD_ONLY:结果记录指针只能向下移动

ResultSet.TYPE_SCROLL_INSENSITIVE:------可以上下移动，但数据库内容发生变化时，结果集不变

ResultSet.TYPE_SCROLL_SENSITIVE:------可以上下移动，但数据库内容变化时，结果集也跟随着变化

ResultSet.CONCUR_READ_ONLY:结果记录集只读

ResultSet.CONCUR_UPDATABLE:结果记录集可更新数据库中数据

下一步是用Hibernate测试sql2000

Fighting!!

已有 0 人发表回复，猛击->>这里<<-参与讨论

JavaEye推荐

现在用grails来做项目是不是太激进

JavaEye网站 — Wed, 08 Oct 2008 15:47:12 +0800

作者: 范三山链接：http://www.javaeye.com/topic/250349 发表时间: 2008年10月08日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

现在要做一个互联网的项目，不是很大。人员大概就是两个java程序员，美工另算。我一直以为，用java来做中小型的互联网项目不是一个明智的选择。这个项目如果我们按照以往的方法不外乎是struts2+spring+hibernate，我觉得效率不是很高。
    我前一段时间自己弄过一下grails，写了一个blog程序，感觉非常棒。我想这个项目用grails十分的不错，因为时间比较紧，用grails来做会非常的快。但是我现在有一些担心
    1.grails的性能问题，不过我不太相信瓶颈会出现在程序端，怎么说也是数据库先有瓶颈。
    2.将来的维护问题，如果我们不在了维护的人还得学grails。
    3.ide不怎么好用，几乎是完全没有作用。我写grails程序一般用netbeans，不知道那位老兄会不会不习惯。IntelliJ IDEA是不会考虑的，实在没有兴趣去搞注册码。
    虽然很看好grails，但是还是会有些担心，不知道大家怎么看的。

已有 53 人发表回复，猛击->>这里<<-参与讨论

JavaEye推荐

hibernate一直的疑问

JavaEye网站 — Fri, 10 Oct 2008 21:16:49 +0800

作者: nlvivian 链接：http://www.javaeye.com/topic/251460 发表时间: 2008年10月10日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

hibernate中,当一个对象持久化将数据库读取后,并将数据保存进缓存中,当第二次读取数据时,它就直接去缓存中取数据了,这点没错吧

用户A访问A机,创建了一个session.检索tableA并对检索结果,持久化.
用户B访问B机,创建了一个session.并对tableA做更新操作.
用户A再次访问持久话的tableA.如果他从缓存中读取tableA的话.不是无法看到.用户B对tableA做的操作了吗?

已有 6 人发表回复，猛击->>这里<<-参与讨论

JavaEye推荐

再谈IOC

JavaEye网站 — Mon, 13 Oct 2008 23:12:19 +0800

作者: bloodrate 链接：http://www.javaeye.com/topic/252418 发表时间: 2008年10月13日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

今天看POJOs IN ACTION书中有类似这样一段话“传统的J2EE应用程序使用JNDI作为一个组件访问另外一个组件的依据，比如JNDI访问EJB组件，JNDI访问Datasource获取服务器上的数据库连接池中的连接，但是JNDI的弱点在于它把应用程序和应用服务器耦合在一起，难于测试和维护。而Spring提供的IOC可以提供一种更为灵活的一个组件访问一个另一个组件的机制，并且与应用服务器脱离耦合。”

那么我可以简要分析出，IOC是某种意义上是作为JNDI的取代品出现的，这也和Martin Fowler对IOC的讲法一致：IOC作为一个系统中“组件插槽”的身份出现的，IOC鼓励程序员基于组建开发督促程序员多写POJO，而绝非是DaoFactory这样的工厂类替代品。

那么我产生疑惑，IOC作为一个系统访问各个基础组件的访问机制，是否能起到真正作用呢？是否它真的比JNDI强呢？考虑这样一种情况：如果一个很大型的系统，有很多子系统，而这些子系统有公用了一些服务，由你来开发这个服务。
如果是JNDI，你将服务部单独署在应用服务器里，然后告诉每个系统负责人你的JNDI，他们就可以访问使用，如若你想维护更新修改你的服务，你只需进行自己的修改而不用告诉大家，因为大家只用你的jndi接口。如果是IOC，你维护了你自己写的服务，还要告诉大家“喂，开会了，大家把我新写的JAR拷走吧，部署在你们的classpath下”这看起来没什么，但是子系统多了，难免出现版本混乱问题。

我是觉得IOC确实看起来只像是一个工厂，而不像一个注册服务的地方。至少它没能让服务组件实现“可单独维护”，反而JNDI接近服务理念，服务的目的就是服务的变化相对于服务使用者透明。。。。。。

已有 0 人发表回复，猛击->>这里<<-参与讨论

JavaEye推荐

Struts验证框架与一些技巧

JavaEye网站 — Sun, 12 Oct 2008 16:36:01 +0800

作者: folie2006 链接：http://www.javaeye.com/topic/251827 发表时间: 2008年10月12日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

还是通过一些步骤例子说明
首先建立Struts工程的时候要启动验证框架。
它称为Validator验证框架
主要依赖与两个.jar文件

Jakarta-oro.jar
Commons-validator.jar

这个是在struts-config.xml文件中如下加入配置之后即代表该工程已经使用验证框架的插件了

完成好了之后以注册的例子说明它的主要使用方法
1.建立一个注册的页面；包含用户名: 密码: 年龄: 邮箱:都不能为空。密码长度必须大于或等于8位，邮箱格式验证等
显示方式一：使用错误消息显示在相应的控件后面。
2.建立注册页相对应的表单Bean(ActionForm),重点在这里，因为要使用验证框架的话该表单类需要修改
1)修改该类的继承

  import org.apache.struts.validator.ValidatorForm;// 导入要继承的类 
  public class 表单类 extends ValidatorForm //修改继承类

2) //修改该类且不包含validate()方法.
3、在validation.xml 中配置验证规则
这个验证规则依赖与validator-rules.xml此文件已经配置好的验证类
大概介绍几种规则吧{}中的为参数
   errors.required={0} is required.      必须的，或者不能为空的
   errors.minlength={0} can not be less than {1} characters. {某某}不能小于{多少}位
   errors.maxlength={0} can not be greater than {1} characters.{ 某某}不能大于{多少}位
errors.range={0} is not in the range {1} through {2}.{0}是不能在{1}与{2}之间

   
   
  

     
       
             arg0指要为该规则传入的第一个参数 

 

 
       
       
       
        minlength 
        8 
       
     
 
    
    

 
       
     
 

     
       
       
       
        
         min 
         1 
        
        
         max 
         100

4、编写消息资源文件

验证规则的配置文件中所用key的名字为该资源文件所配置

# errors.required={0}不能为空. 
# tip.username=用户名 
# tip.userpass=密码 
# errors.minlength={0}不能少于{1}个字符. 
# errors.email={0} 格式不合法. 
# tip.email=邮箱 
# tip.age=年龄 
# errors.range={0} 必须在 {1} - {2} 之间. 

errors.required={0}\u4e0d\u80fd\u4e3a\u7a7a. 
tip.username=\u7528\u6237\u540d 
tip.userpass=\u5bc6\u7801 
errors.minlength={0}\u4e0d\u80fd\u5c11\u4e8e{1}\u4e2a\u5b57\u7b26. 
errors.email={0} \u683c\u5f0f\u4e0d\u5408\u6cd5. 
tip.email=\u90ae\u7bb1 
tip.age=\u5e74\u9f84 
errors.range={0} \u5fc5\u987b\u5728 {1} - {2} \u4e4b\u95f4.

5.在struts-config.xml中配置Action验证失败跳转页面，属性为input指向的地方

二、手工验证；
1、用户名、密码不能为空；
2、密码长度不能小于8位；

（1）验证代码写在哪儿？
ActionForm的validate()方法中，如果该方法返回的ActionErrors中没有包含错误消息，认为验证通过。

（2）错误集合存在哪儿？
由 RequestProcessor 将错误集合存储在 Request 中，键名为
Globas.ERROR_KEY；

（3）如何显示错误消息？

三、生成JavaScript
（1）ActionForm继承 org.apache.struts.validator.ValidatorForm；
（2）ActionForm中无 validate() 方法；
（3）表单JSP页中加：
颜色字体一致，首字母大写

（4）在validation.xml中配置验证规则；

另外再说一个不怎么常用的标签，它的作用一般就是方便表单Bean对象的重复代码

<%@ taglib uri="/WEB-INF/struts-nested.tld" prefix="nested" %> 
用户注册 
 
     
    用户名:
 
    密码:

要使用该配置，在ActionForm中要实例化一个user对象才可以通过以上配置使用对象中username的属性

 
用户注册 
 
    用户名:
 
    密码:

上面的代码也可以实现刚才的功能，但是在验证框架中就不能那么使用了

Tiles标签

作用与嵌套网页，可以定制好一个模板，然后在模板中使用相应的可编辑内容

t1.jsp 
111111111111111

第二种情况是以一个定制了的模板生成个新的网页

（1）防止重复提交； Action
原理是通过在请求里面加入一些身份标记，在请求的时候判断是否事先存放的标记，如果不是则是第二次非正常提交

this.saveToken(request);        //在第一次点击请求的时候存入然后存转发到另一个JSP页面 
//判断令牌是否有效； 
if(! this.isTokenValid(request) ){     //如果是刚才的页面转发过来的话则它返回真 
saveToken(request); 
return ( new ActionForward(mapping.getInput()) );  
//跳转到Action配置的input中的页面 
} 
//最后正常执行完业务逻辑就把先前存的Token删除 
request.removeAttribute(mapping.getAttribute()); 
this.resetToken(request);

（2）动态ActionForm（对应的JAVA类是动态产生的，JAVA类中的属性在struts-config.xml文件中动态配置）
1.配置Struts-config.xml中的，在其中声明
表单中要包含的字段元素；
----------------------------------------
例如页面上有以下一个表单，分别有属性username userage

 
username:
 
userage:

那么对应这个表单就要在Struts-config.xml中配置一个与其对应的form-bean

----------------------------------------------------
2.配置Struts-config.xml中的，将动态ActionForm
与某个Action结合起来;
只要name属性名称一致就可以了
在Action中的业务方法有些改动，因为它自动生成表单bean,所以取值的时候要像这样取,get中填写xml配置中的属性名字,把form强转换成DynaActionForm类对象，使用.get方法，返回Object，所以相应的再强转成想要的类型
String username=(String)((DynaActionForm)form).get("username");
Integer userage=(Integer)((DynaActionForm)form).get("userage");
3.客户使用表单,表单中名称与中声明的相同；

最后在使用完表单bean之后要删除掉刚才生成的bean;方法如下
request.removeAttribute(mapping.getAttribute());//删除FormBean

(3)DispatchAction类，可以在一个Action中编写多个业务方法;
1、编写Action，要继承DispatchAction，且无execute()方法；
2、在Action类中提供多个业务方法；
3、在表单/超链接中生成请求时，用URL： xxxxx.do?method=XX
4、使用该类，可以节省Action的个数;

测试DispatchAction类(一个Action处理多种业务):
加math.do?method=add
减math.do?method=dec
乘math.do?method=mul

在Action类中要写入相应的方法。

public ActionForward add(ActionMapping mapping, 
                            ActionForm form, 
                            HttpServletRequest request, 
                            HttpServletResponse response) 
    throws Exception { 
    System.out.println("add...."); 
    request.setAttribute( "mathresult","add...." ); 
    return mapping.findForward( "success" ); 
    }

其他几个以此类推。。。。。。。。。。。。

(4)一个表单实现多种业务（计算器）----LookupDispatchAction;
LookupDispatchAction(一个表单对应多个处理方法):

1、编写Action，继承LookupDispatchAction类；
2、重写LookupDispatchAction类的getKeyMethodMap()，在该方法内对提交按钮文字“键名”和“业务方法名”进行映射；

protected Map getKeyMethodMap(){ 
Map map=new HashMap(); 
map.put("页面显示的按钮","本类中的业务方法名"); 
map.put("button.add ","add"); 
return map; 
}

3、编写业务方法；

//add 
    public ActionForward add(ActionMapping mapping, 
                                 ActionForm form, 
                                 HttpServletRequest request, 
                                 HttpServletResponse response) 
    throws Exception 
    { 

        int num1 = ((Math2Form) form).getNum1(); 
        int num2 = ((Math2Form) form).getNum2(); 
request.setAttribute( "math2Result", ""+(num1+num2) ); 
        request.removeAttribute(mapping.getAttribute()); 
        return (mapping.findForward("success")); 
    }

4、表单中的提交按钮中，显示文字时使用

5、使用该类，可以出现许多避免重复性表单；(如下为前台表单显示的内容)

(5)ForwardAction

已有 1 人发表回复，猛击->>这里<<-参与讨论

JavaEye推荐

让你的 Ibatis2 也支持Annotation

JavaEye网站 — Fri, 10 Oct 2008 07:17:02 +0800

作者: cnoss 链接：http://www.javaeye.com/topic/251047 发表时间: 2008年10月10日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

在支持xml配置方式的基础上增加了对annotation的支持，用户可以根据自己的喜好来选择或者两种方式并存。

详情请大家看：http://www.rest4g.org/viewthread.php?tid=12&extra=page%3D1

代码示例如下：
Account.java

package org.jrest4guice.persistence.ibatis;
public class Account {
  private int id;
  private String firstName;
  private String lastName;
  private String emailAddress;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getFirstName() {
    return firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }

  public String getEmailAddress() {
    return emailAddress;
  }

  public void setEmailAddress(String emailAddress) {
    this.emailAddress = emailAddress;
  }

}

AccountService.java

package org.jrest4guice.persistence.ibatis;

import java.sql.SQLException;
import java.util.List;

import org.jrest4guice.persistence.ibatis.annotations.Delete;
import org.jrest4guice.persistence.ibatis.annotations.IbatisDao;
import org.jrest4guice.persistence.ibatis.annotations.Insert;
import org.jrest4guice.persistence.ibatis.annotations.Result;
import org.jrest4guice.persistence.ibatis.annotations.ResultMap;
import org.jrest4guice.persistence.ibatis.annotations.Select;
import org.jrest4guice.persistence.ibatis.annotations.Update;
import org.jrest4guice.transaction.annotations.Transactional;
import org.jrest4guice.transaction.annotations.TransactionalType;

import com.google.inject.Inject;
import com.ibatis.sqlmap.client.SqlMapClient;

@IbatisDao
@SuppressWarnings("unchecked")
@Transactional
@ResultMap(id = "accountResultMap", result = {
		@Result(property = "id", column = "id"),
		@Result(property = "firstName", column = "firstName"),
		@Result(property = "lastName", column = "lastName"),
		@Result(property = "emailAddress", column = "emailAddress") }, resultClass = Account.class)
@Cachemodel(id = "account-cache", flushInterval = "24", flushOnExecute = {
		"insertAccount", "updateAccount", "deleteAccount" }, type = "LRU", 
		property = { @Property(name = "size", value = "100") })
public class AccountService {
	@Inject
	private SqlMapClient sqlMapper;

	@Select(id = "selectAllAccounts", sql = "select * from ACCOUNT", 
			resltMap = "accountResultMap", cacheModel = "account-cache")
	@Transactional(type = TransactionalType.READOLNY)
	public List findAll() throws SQLException {
		return sqlMapper.queryForList("selectAllAccounts");
	}

	@Select(sql = "select id ,firstName,lastName,emailAddress from "
			+ "ACCOUNT where id = #id#")
	@Transactional(type = TransactionalType.READOLNY)
	public Account getAccountById(int id) throws SQLException {
		return (Account) sqlMapper.queryForObject("getAccountById", id);
	}

	@Insert(id = "insertAccount", sql = "insert into ACCOUNT (id,firstName,"
			+ "lastName,emailAddress) values (#id#, #firstName#, #lastName#, "
			+ "#emailAddress#)")
	public void createAccount(Account account) throws SQLException {
		sqlMapper.insert("insertAccount", account);
	}

	@Update(sql = "update ACCOUNT set firstName = #firstName#,lastName = "
			+ "#lastName#,emailAddress = #emailAddress# where id = #id#")
	public void updateAccount(Account account) throws SQLException {
		sqlMapper.update("updateAccount", account);
	}

	@Delete(id = "deleteAccount", sql = "delete from ACCOUNT where id = #id#")
	public void deleteAccount(int id) throws SQLException {
		sqlMapper.delete("deleteAccount", id);
	}

	@Select(id = "queryAccounts", 
		sql = "select * from ACCOUNT "
			+ ""
			+ " "
			+ "    firstName = #firstName#" 
			+ " "
			+ " "
			+ "    lastName = #lastName#" 
			+ " "
			+ " "
			+ "    emailAddress = #emailAddress#" 
			+ " "
			+ " " 
			+ "order by lastName", resltMap = "accountResultMap", 
			cacheModel = "account-cache")
	@Transactional(type = TransactionalType.READOLNY)
	/**
	 * 动态SQL查询
	 */
	public List queryAccounts(Account account) throws SQLException {
		return sqlMapper.queryForList("queryAccounts",account);
	}
}

AccountServiceTest.java

package org.jrest4guice.persistence.ibatis;

import java.sql.SQLException;
import java.util.List;

import junit.framework.Assert;

import org.jrest4guice.guice.GuiceContext;
import org.jrest4guice.guice.PersistenceGuiceContext;
import org.junit.BeforeClass;
import org.junit.Test;

public class AccountServiceTest {
	private static AccountService service;

	@BeforeClass
	public static void setUp() throws Exception {
		// 初始化JRest4Guice
		PersistenceGuiceContext.getInstance().useIbatis(
				"org.jrest4guice.persistence.ibatis").init();
		// 获取服务
		service = GuiceContext.getInstance().getBean(AccountService.class);
	}

	@Test
	public void doTest() {
		List accounts;
		try {
			Account account = new Account();
			account.setFirstName("张");
			account.setLastName("学友");
			account.setEmailAddress("jackey@rest4g.org");
			// 添加
			service.createAccount(account);

			account = new Account();
			account.setFirstName("刘");
			account.setLastName("学友");
			account.setEmailAddress("test@rest4g.org");
			// 添加
			service.createAccount(account);
			
			//查询（按lastName）
			Account queryCondition = new Account();
			queryCondition.setLastName("学友");
			accounts = service.queryAccounts(queryCondition);
			Assert.assertEquals(2, accounts.size());
			
			//查询（按firstName和lastName）
			queryCondition.setFirstName("张");
			accounts = service.queryAccounts(queryCondition);
			Assert.assertEquals(1, accounts.size());

			// 修改
			account = accounts.get(0);
			account.setFirstName("何");
			service.updateAccount(account);
			account = service.getAccountById(account.getId());
			Assert.assertNotNull(account);
			Assert.assertEquals("何", account.getFirstName());

			//查询所有
			accounts = service.findAll();
			Assert.assertEquals(2, accounts.size());

			// 删除
			for (Account ac : accounts){
				service.deleteAccount(ac.getId());
			}
			
			//断言删除的结果
			accounts = service.findAll();
			Assert.assertEquals(0, accounts.size());
		} catch (SQLException e) {
			Assert.fail(e.getLocalizedMessage());
		}
	}
}

已有 46 人发表回复，猛击->>这里<<-参与讨论

JavaEye推荐

在web集群环境下如何实现网站全局变量

JavaEye网站 — Sun, 12 Oct 2008 19:15:31 +0800

作者: shinewang 链接：http://www.javaeye.com/topic/251854 发表时间: 2008年10月12日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

最近正在开发一个网站，碰到一个关于web集群环境下全局变量实现的问题，例如网站是否开放用户注册，禁用的IP列表这类不经常更改却频繁调用的系统设置，如何实现才能保证不影响系统性能，并且修改后能及时更新到每台服务器？

考虑想了几种方法：
1.存在数据库中，每次调用时去查数据库
每次都需要查数据库会不会影响性能？

2.存在数据库中，本地有一个config类作缓存，每隔一段时间调用计划任务和数据库同步一下
更新后同步到其他服务器需要一段时间，不是很及时

3.存在数据库中，本地有一个config类作缓存，用JMS发送/接收更新数据
需要引入JMS

4.直接写在config类中，不提供在web界面的修改配置，修改配置需要改写config类，然后重新部署到各服务器
修改配置需要修改代码，管理起来不方便，另外java的热部署只更新这个修改了的config类吗，会不会影响jvm里面其他的类，也就是会不会影响用户？

5.存在配置文件中每次读文件，更新时同上一方案
性能？热部署？

这个问题应该很简单吧，由于不是做互联网的，没什么经验。各位有什么好的想法？

已有 3 人发表回复，猛击->>这里<<-参与讨论

JavaEye推荐

折腾百度空间

JavaEye网站 — Mon, 13 Oct 2008 15:59:23 +0800

作者: chbest 链接：http://www.javaeye.com/topic/252287 发表时间: 2008年10月13日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

公司要做个人空间sns类似的模块.
最先考虑的就是百度空间.
自己有个百度空间的账号.
hi.baidu.com/水痕2000
无论在ie还是火狐上面敲,都能成功访问.一想百度还真厉害.这样也成?
utf-8 和gbk都处理的这么好
在接着:
申请账号:水痕水痕
申请gbk下'水痕水痕'对应的账号:姘寸棔姘寸棔
然后在ie和火狐下进入:
hi.baidu.com/水痕水痕 || hi.baidu.com/姘寸棔姘寸棔
发现hi.baidu.com/姘寸棔姘寸棔在火狐下是进入水痕水痕的空间;在ie下进入的姘寸棔姘寸棔的空间.
然后在姘寸棔姘寸棔空间下点blog或者相册模块,又跑到水痕水痕里面去了.
得出结论:用中文名做url的path是不可取的.
1 百度默认连接是用gbk编码的
2 百度处理请求的时候,默认以utf-8进行转译,查询不到数据库在用gbk;
基本来说姘寸棔姘寸棔的空间很难点进去
最后放上连接:
http://hi.baidu.com/%E6%B0%B4%E7%97%95%E6%B0%B4%E7%97%95
http://hi.baidu.com/%CB%AE%BA%DB%CB%AE%BA%DB
都是进一个空间

已有 2 人发表回复，猛击->>这里<<-参与讨论

JavaEye推荐

Ejb3.0--1

JavaEye网站 — Mon, 13 Oct 2008 17:57:49 +0800

作者: xiaocong1001 链接：http://www.javaeye.com/topic/252343 发表时间: 2008年10月13日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Ejb3.0--1
今天学习了一下午的ejb3.0遇见了一些麻烦，拿出来和大家分享一下。以免大家以后遇到同样的问题
A）首先，我下载了jboss服务器，这个是ejb的运行环境，必不可少。
B）我将他解压到/usr/jboos下，然后修改用户的profile文件vi /home/xiaocong/.bash_profile ；在里面添加
export JBOSS_HOME=/usr/jboss;
export PATH= $PATH:$JBOSS_HOME/bin;
(注）我已经安装了jdk1.5，并且已经设置好环境变量了，还要注意jboss文件夹的所有者啊！必要的时候使用root用户，chown一下。
C）ok，现在可以运行一下jboss了。
D）打开我的IDE，新建一个ejb工程HelloWorld。
E）创建个自己的包com.chenzhq.ejb.
F）创建一个无状态的会话bean(stateless session bean)的远程接口HelloWorldRemote.

package com.chenzhq.ejb;

import javax.ejb.Remote;

@Remote ({HelloWorldRemote.class})
public interface HelloWorldRemote {

	   public String say(String name);
}

G）创建Remote接口的实现。

package com.chenzhq.ejb;

import javax.ejb.Local;
import javax.ejb.Remote;
import javax.ejb.Stateless;

@Stateless//注意这里啊
@Remote ({HelloWorldRemote.class})//注意这里啊

public class HelloWorld implements HelloWorldRemote {

	   public String say(String name){
		   System.out.println(HelloWorld.class.getCanonicalName());
		   return name;
	   }
}

H）ok，写个ant脚本

I）将helloworld.jar复制到/usr/jboss/server/all/deploy下。看看控制台是否有输出
15:40:51,714 INFO [JmxKernelAbstraction] installing MBean: jboss.j2ee:jar=helloworld.jar,name=HelloWorld,service=EJB3 with dependencies:
15:40:51,757 INFO [EJBContainer] STARTED EJB: com.chenzhq.ejb.HelloWorld ejbName: HelloWorld
15:40:51,781 INFO [EJB3Deployer] Deployed: file:/usr/jboss/server/default/deploy/helloworld.jar
如果有上面的输出，说明是成功部署了。
在ie里输入http://ip：port访问jboss的jmx-console点击service=jndiView，然后是点击Output JNDI info as text下的invoke，查找HelloWorld。
J）在client端调用ejb的代码。

package com.chenzhq;

import java.util.Properties;

import javax.naming.InitialContext;
import javax.naming.NamingException;

import com.chenzhq.ejb.HelloWorldRemote;

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Properties props = new Properties();
		props.setProperty("java.naming.factory.initial", "org.jnp.interfaces.NamingContextFactory");
		props.setProperty("java.naming.provider.url", "jnp://192.168.0.2:1099");//这里是我部署ejb的主机地址。
		props.setProperty("java.naming.factory.url.pkgs", "org.jboss.naming"); 
		
		try {
			InitialContext ic = new InitialContext(props);
			HelloWorldRemote hwr = ((HelloWorldRemote)ic.lookup("HelloWorld/remote"));
			System.out.println(hwr.say("chenzhq"));
			
		} catch (NamingException e) {
			// TODO Auto-generated catch block
			System.out.print(e);
			e.printStackTrace();
		}
		
		// 

	}

}

Ok了，待续。。。。。。。。。。。。 :D :D :D :D

已有 0 人发表回复，猛击->>这里<<-参与讨论

JavaEye推荐

hibernate-memcached补丁：支持Whalin的MemCached Java客户端

JavaEye网站 — Thu, 09 Oct 2008 00:03:19 +0800

作者: movingboy 链接：http://www.javaeye.com/topic/250534 发表时间: 2008年10月09日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

hibernate-memcached（http://code.google.com/p/hibernate-memcached/）是允许hibernate使用MemCached作为二级缓存的项目，它用到了spymemcached（http://code.google.com/p/spymemcached/）这个MemCached的Java客户端。花了一点时间做了个补丁，让它也支持Whalin的Java客户端（http://whalin.com/memcached/）。

所有的代码（包括原hibernate-memcached的所有源码）、javadoc及重新制作的发布包请见附件，限于篇幅就不具体说明了。以下是我更新过的hibernate-memcached的配置说明，原配置说明请参见http://code.google.com/p/hibernate-memcached/wiki/Configuration

Adding hibernate-memcached to your application

If you are using Maven2 for your application build you can follow the instructions on the MavenRepository page. For those that aren't using Maven2 you'll need to collect a few simple jars for yourself. I am going to assume you already have hibenrnate3 setup before you came here.

You'll need...

hibernate-memcached-.jar
commons-codec 1.3
slf4j-1.5.0.jar
An slf4j implementation for your preferred logging framework. For log4j you can use slf4j-log4j12-1.5.0.jar.

If you are using spymemcached as the MemCached client, you also need

or if you prefer Whalin's memcached client for java, you need to download java_memcached-release_2.0.1.jar from the download page according to your Java VM version.

Configuring Hibernate

The first thing to do is to tell hibernate which cache provider you'd like to use, and to enable the second level cache.

hibernate.cache.provider_class

com.googlecode.hibernate.memcached.MemcachedCacheProvider

Using just the property above you get basic entity caching by default. The hibernate-memcached library supports query caching, but you have to enable query caching separately.

hibernate.cache.use_query_cache

true

!Now you can start setting up the hibernate-memcached specific properties. The hibernate-memcached properties are divided into two categories; cache-wide settings and cache-region settings.

Cache Wide Settings

The cache wide settings all have defaults can mostly be overwritten at a cache-region level. For both spymemcached and Whalin's client, you can set:

Property	Default	Description
hibernate.memcached.servers	localhost:11211	Space delimited list of memcached instances in host:port format
hibernate.memcached.cacheTimeSeconds	300	The default number of seconds items should be cached. Can be overriden at the regon level.
hibernate.memcached.keyStrategy	HashCodeKeyStrategy	Sets the strategy class to to use for generating cache keys. Must provide a class name that implements KeyStrategy
hibernate.memcached.clearSupported	false	Enables support for the MemcachedCache.clear() method for all cache regions. The way clear is implemented for memcached is expensive and adds overhead to all get/set operations. It is not recommended for production use.

For spymemcached, you can set:

hibernate.memcached.readBufferSize	DefaultConnectionFactory.DEFAULT_READ_BUFFER_SIZE	The read buffer size for each server connection from this factory
hibernate.memcached.operationQueueLength	DefaultConnectionFactory.DEFAULT_OP_QUEUE_LEN	Maximum length of the operation queue returned by this connection factory
hibernate.memcached.operationTimeout	DefaultConnectionFactory.DEFAULT_OPERATION_TIMEOUT	Default operation timeout in milliseconds
hibernate.memcached.hashAlgorithm	HashAlgorithm.KETAMA_HASH	Which hash algorithm to use when adding items to the cache. Note: the MemcachedClient defaults to using HashAlgorithm.NATIVE_HASH, while the hibernate-memcached cache defaults to KETAMA_HASH for "consistent hashing"

For Whalin's client, you can set:

hibernate.memcached.weights		Space delimited list of server weights. If not set, all servers get the same weight
hibernate.memcached.errorHandler	com.googlecode.hibernate.memcached. dangamemcached.SimpleErrorHandler	Error handler used by Whalin's client internally
hibernate.memcached.poolName	default	The name of SockIOPool
hibernate.memcached.initConn	1	Initial pool size
hibernate.memcached.minConn	1	Min pool size
hibernate.memcached.maxConn	10	Max pool size
hibernate.memcached.maxIdle	3000000	Max idle time for available sockets. Default 5 minutes
hibernate.memcached.socketTimeout	30000	Default timeout of socket reads. Default 30 seconds
hibernate.memcached.socketConnectTimeout	3000	Default timeout of socket connections. Default 3 seconds
hibernate.memcached.maintSleep	30000	Maintenance thread sleep time. Default 30 seconds
hibernate.memcached.compressEnable	true	If compression enabled
hibernate.memcached.defaultEncoding	UTF-8	Default encoding

Cache Region Settings

Cache regon properties are set by giving your cached data a "region name" in hibernate. You can tune the MemcachedCache instance for your region using the following properties. These properties essentially override the cache-wide properties above.

Property	Default	Description
hibernate.memcached.[region-name].cacheTimeSeconds	none, see hibernate.memcached.cacheTimeSeconds	Set the cache time for this cache region, overriding the cache-wide setting.
hibernate.memcached.[region-name].keyStrategy	none, see hibernate.memcached.keyStrategy	Overrides the strategy class to to use for generating cache keys in this cache region. Must provide a class name that implements KeyStrategy
hibernate.memcached.[region-name].clearSupported	none, see hibernate.memcached.clearSupported	Enables clear() operations for this cache region only. Again, the clear operation incurs cost on every get/set operation.

已有 2 人发表回复，猛击->>这里<<-参与讨论

JavaEye推荐

Android入门扫盲之二

JavaEye网站 — Sun, 12 Oct 2008 22:51:44 +0800

作者: LinuxFans 链接：http://www.javaeye.com/topic/251964 发表时间: 2008年10月12日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

资源的引用

在Android开发中对资源的引用是很重要的内容，看一个Android工程结构的好与坏，其实看看工程结构的资源文件的相互关系就大概可以看出来了，个人觉得学习好Android，资源文件是很重要的部分，这里讲的都是些入门级别的知识点，耐下心思看哦，呵呵。

1，三种资源文件形式。资源文件之间的相互引用自然是基础的基础，三种形式(android:xxx/yyy,@xxxx/yyy,?xxx)的区别要彻底地弄明白。

2，资源文件的属性命名。资源文件属性的命名(其实大部分是id名字，也有其它的，这里不再累赘)对于初学者可能不太会在意，其实是很重要的部分，它其实也就是一些我们预先定义好的变量，能不在乎吗，这些变量会在自动生成映射类R.java中生成一些静态索引值，帮助Android快速定位，命名说白了，也是要求我们做到望名知意(最好包括类型)。

3，每个工程都会有对应的一个AndroidManifest.xml文件，这个文件要注意的是一些权限的表示属性，如：

<uses-permission android:name="android.permission.INTERNET" />

<uses-permission android:name="android.permission.READ_CONTACTS" />

<uses-permission android:name="android.permission.WRITE_CONTACTS" />

<uses-permission android:name="android.permission.INSTALL_PACKAGES" />

<uses-permission android:name="android.permission.DELETE_PACKAGES" />

看命名就知道是针对什么做权限限制，所以初学者要注意了，在你的程序运行的时候报SecurityException的时候要看看你的程序是否涉及到限制操作，呵呵。这些在android.Manifest.permission里面，大家自己看可能会更好，自己学习的能力很重要哦，要不然你做的不可能是前沿的东西啦。

4，自己定义类的引用。怎么定义、怎么使用，可以参考ApiDemo里面的经典实例：com.example.android.apis.view.LableView.java 。这也是很重哦，因为在我们开发的过程中,Android提供的UI肯定不能满足我们的要求，这样你就得自己写新的UI类，我在开发中就遇到很多这样的问题。如，Android现有的TabHost，在TabSpec多的时候你就感觉出TabHost英雄无用武之地啦，这样就得自己写了。

写自己的Android Components

上面的第四点已经提到了一下，学会写自己的控件的重要性。在Android里面，提供了丰富的类库，如何使用好也是值得探讨的问题。当然这里说的也是api里面说的，这里说的主要是我在学习的过程中认为很重要的方面.

主要把界面布局类：LinearLayout和FrameLayout弄懂简单的开发就够了，再深入一点就要把ViewManager及其子类弄清楚了。

其中，LinearLayout垂直和水平两种，他们之间可以相互嵌套，嵌套时候要注意高和宽的属性，如。

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:app="http://schemas.android.com/apk/res/com.srk.study"

android:id="@+id/screen" android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:background="@drawable/background" android:focusable="true"

android:orientation="vertical">

<LinearLayout android:layout_width="fill_parent"

android:layout_height="65dip"

android:background="@drawable/background"

android:orientation="horizontal">

<com.srk.study.model.TitleView android:id="@+id/titleView"

android:layout_width="280dip" android:layout_height="65dip"

android:paddingLeft="5dip" android:paddingTop="10dip"

app:focusBgColor=@drawable/whiteColor app:titleColor=@drawable/blackColor

app:titleSize="15dip" />

<com.srk.study.model.ConnectView android:id="@+id/connectView"

android:layout_height="65dip"

android:layout_width="40dip" app.startX="280dip" />

LinearLayout>

<ListView android:id="@+id/bodyListView" android:layout_width="fill_parent"

android:paddingTop="3dip" android:layout_height="wrap_content"

android:layout_weight="1.0"

android:persistentDrawingCache="animation|scrolling"

android:scrollbars="vertical" android:focusable="true"

android:scrollbarSize="12dip" />

LinearLayout>

以上的配置文件是我学习过程的小练习，在这里秀一下，哈哈，记得在去年刚毕业的时候，特别爱学习，什么都想弄弄，在去年一年的时光中，每天都过得很充实，也许那就是年轻的标志吧，扯远了。今天就说这么多，有空分享点源代码出来。。。

已有 1 人发表回复，猛击->>这里<<-参与讨论

JavaEye推荐

用 oml4j 解释 office2007 docx 文档

JavaEye网站 — Sun, 12 Oct 2008 23:20:22 +0800

作者: pzzy2000 链接：http://www.javaeye.com/topic/251969 发表时间: 2008年10月12日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

这几天在做项目的时候，需要把一些工程文档用WEB 显示出来，本人有点懒，不想集成web 页面编辑控件。
就在 group.google.com，找到 http://groups.google.com/group/oxml4j 工程，用来解释 docx 文档的；

    1 : 先从 http://code.google.com/p/oxmlj/ 下载需要的 jar lib ;

    2: 写了个解释TEST;

               DocumentFactory oxmlPaserFactory = new ReadDocumentFactory();

XDocument document = oxmlPaserFactory.getXDocument(ocxFile);

List paragraphs=document.getParagraph();

for(int i=0;i {

Paragraph paragraph=paragraphs.get(i);

System.out.println("-- "+paragraph.getText()+" "+paragraph.getStyle()+"   image : "+paragraph.getImages());
}

     竟然可以解析出段落文档；

        paragraph.getImages()；好像是可以解析出docx 文档中的图片的；

         我用 struts2 ,
             String getImages()throws Exception
{
             HttpServletResponse response = ServletActionContext.getResponse();
              response.wirte(paragraph.getImages());

}
             在页面上用
             可以显示图片；

       竟然成功了。。

     好高兴，这样可以省了很多的代码；
    项目可以提前完成了；

已有 1 人发表回复，猛击->>这里<<-参与讨论

JavaEye推荐