找到my.ini文件

添加一句max_allowed_packet=16m，如果不行将16m再加大

加大wait_timeout也可起一定作用

eg:

wait_timeout=2880000
interactive_timeout = 2880000
max_allowed_packet = 100m

应用时记住重启数据库哦～～

	林花谢了春红，
	太匆匆，
	无奈朝来寒雨晚来风。
	胭脂泪，
	相留醉，
	几时重，
	自是人生长恨水长东。
 * 

action_packages = null; private final static threadlocal g_json_enabled = new threadlocal(); @override public void init() throws servletexception { string tmp = getinitparameter("packages"); action_packages = arrays.aslist(stringutils.split(tmp,',')); string initial_actions = getinitparameter("initial_actions"); for(string action : stringutils.split(initial_actions,',')) try { _loadaction(action); } catch (exception e) { log("failed to initial action : " action, e); } } @override public void destroy() { for(object action : actions.values()){ try{ method dm = action.getclass().getmethod("destroy"); if(dm != null){ dm.invoke(action); log("!!!!!!!!! " action.getclass().getsimplename() " destroy !!!!!!!!!"); } }catch(nosuchmethodexception e){ }catch(exception e){ log("unabled to destroy action: " action.getclass().getsimplename(), e); } } super.destroy(); } @override protected void doget(httpservletrequest req, httpservletresponse resp) throws servletexception, ioexception { process(requestcontext.get(), false); } @override protected void dopost(httpservletrequest req, httpservletresponse resp) throws servletexception, ioexception { process(requestcontext.get(), true); } /** * 执行action方法并进行返回处理、异常处理 * @param req * @param resp * @param is_post * @throws servletexception * @throws ioexception */ protected void process(requestcontext req, boolean is_post) throws servletexception, ioexception { try{ req.response().setcontenttype("text/html;charset=utf-8"); if(_process(req, is_post)){ string gp = req.param(goto_page); if(stringutils.isnotblank(gp)) req.redirect(gp); } }catch(invocationtargetexception e){ throwable t = e.getcause(); if(t instanceof actionexception) handleactionexception(req, (actionexception)t); else if(t instanceof dbexception) handledbexception(req, (dbexception)t); else throw new servletexception(t); }catch(actionexception t){ handleactionexception(req, t); }catch(ioexception e){ throw e; }catch(dbexception e){ handledbexception(req, e); }catch(exception e){ log("exception in action process.", e); throw new servletexception(e); }finally{ g_json_enabled.remove(); } } /** * action业务异常 * @param req * @param resp * @param t * @throws servletexception * @throws ioexception */ protected void handleactionexception(requestcontext req, actionexception t) throws servletexception, ioexception { handleexception(req, t.getmessage()); } protected void handledbexception(requestcontext req, dbexception e) throws servletexception, ioexception { log("dbexception in action process.", e); handleexception(req, resourceutils.getstring("error", "database_exception", e.getcause().getmessage())); } /** * url解码 * * @param url * @param charset * @return */ private static string _decode { if (stringutils.isempty(url)) return ""; try { return urldecoder.decode(url, charset); } catch (exception e) { } return url; } protected void handleexception(requestcontext req, string msg) throws servletexception, ioexception { string ep = req.param(error_page); if(stringutils.isnotblank(ep)){ if(ep.charat(0)=='%') ep = _decode; ep = ep.trim(); if(ep.charat(0)!='/'){ req.redirect(req.contextpath() "/"); } else{ req.request().setattribute(error_msg, msg); req.forward(ep.trim()); } } else{ if(g_json_enabled.get()) req.output_json("msg", msg); else req.print(msg); } } /** * 业务逻辑处理 * @param req * @param resp * @param is_post_method * @throws illegalaccessexception * @throws instantiationexception * @throws ioexception * @throws servletexception * @throws ioexception * @throws invocationtargetexception * @throws illegalargumentexception */ private boolean _process(requestcontext req, boolean is_post) throws instantiationexception, illegalaccessexception, ioexception, illegalargumentexception, invocationtargetexception { string requesturi = req.uri(); string[] parts = stringutils.split(requesturi, '/'); if(parts.length<2){ req.not_found(); return false; } //加载action类 object action = this._loadaction(parts[1]); if(action == null){ req.not_found(); return false; } string action_method_name = (parts.length>2)?parts[2]:"index"; method m_action = this._getactionmethod(action, action_method_name); if(m_action == null){ req.not_found(); return false; } //判断action方法是否只支持post if (!is_post && m_action.isannotationpresent(annotation.postmethod.class)){ req.not_found(); return false; } g_json_enabled.set(m_action.isannotationpresent(annotation.jsonoutputenabled.class)); if(m_action.isannotationpresent(annotation.userrolerequired.class)){ iuser loginuser = req.user(); if(loginuser == null){ string this_page = req.param(this_page, ""); throw req.error("user_not_login", this_page); } if(loginuser.isblocked()) throw req.error("user_blocked"); annotation.userrolerequired urr = (annotation.userrolerequired) m_action.getannotation(annotation.userrolerequired.class); if(loginuser.getrole() < urr.role()) throw req.error("user_role_deny"); } //调用action方法之准备参数 int arg_c = m_action.getparametertypes().length; switch(arg_c){ case 0: // login() m_action.invoke(action); break ; case 1: m_action.invoke(action, req); break; case 2: // login(httpservletrequest req, httpservletresponse res) m_action.invoke(action, req.request(), req.response()); break ; case 3: // login(httpservletrequest req, httpservletresponse res, string[] extparams) stringbuilder args = new stringbuilder(); for(int i=3;i 0) args.append('/'); args.append(parts[i]); } boolean islong = m_action.getparametertypes()[2].equals(long.class); m_action.invoke(action, req.request(), req.response(), islong ? numberutils.tolong( args.tostring(), -1l) : args.tostring()); break ; default: req.not_found(); return false; } return true; } /** * 加载action类 * @param act_name * @return * @throws instantiationexception * @throws illegalaccessexception * @throws classnotfoundexception */ protected object _loadaction(string act_name) throws instantiationexception,illegalaccessexception { object action = actions.get(act_name); if(action == null){ for(string pkg : action_packages){ string cls = pkg '.' stringutils.capitalize(act_name) "action"; action = _loadactionoffullname(act_name, cls); if(action != null) break; } } return action ; } private object _loadactionoffullname(string act_name, string cls) throws illegalaccessexception, instantiationexception { object action = null; try { action = class.forname(cls).newinstance(); try{ method action_init_method = action.getclass().getmethod("init", servletcontext.class); action_init_method.invoke(action, getservletcontext()); }catch(nosuchmethodexception e){ }catch(invocationtargetexception excp) { excp.printstacktrace(); } if(!actions.containskey(act_name)){ synchronized(actions){ actions.put(act_name, action); } } } catch (classnotfoundexception excp) {} return action; } /** * 获取名为{method}的方法 * @param action * @param method * @return */ private method _getactionmethod(object action, string method) { string key = action.getclass().getsimplename() '.' method; method m = methods.get(key); if(m != null) return m; for(method m1 : action.getclass().getmethods()){ if(m1.getmodifiers()==modifier.public && m1.getname().equals(method)){ synchronized(methods){ methods.put(key, m1); } return m1 ; } } return null; } private final static hashmap actions = new hashmap(); private final static hashmap methods = new hashmap(); }

礼物 2013-08-19 16:41

]]>

一 class的热替换
classloader中重要的方法
loadclass
      classloader.loadclass(...) 是classloader的入口点。当一个类没有指明用什么加载器加载的时候，jvm默认采用appclassloader加载器加载没有加载过的class，调用的方法的入口就是loadclass(...)。如果一个class被自定义的classloader加载，那么jvm也会调用这个自定义的classloader.loadclass(...)方法来加载class内部引用的一些别的class文件。重载这个方法，能实现自定义加载class的方式，抛弃双亲委托机制，但是即使不采用双亲委托机制，比如java.lang包中的相关类还是不能自定义一个同名的类来代替，主要因为jvm解析、验证class的时候，会进行相关判断。
 
defineclass
      系统自带的classloader，默认加载程序的是appclassloader，classloader加载一个class，最终调用的是defineclass(...)方法，这时候就在想是否可以重复调用defineclass(...)方法加载同一个类(或者修改过)，最后发现调用多次的话会有相关错误:
...
java.lang.linkageerror
attempted duplicate class definition
...
所以一个class被一个classloader实例加载过的话，就不能再被这个classloader实例再次加载(这里的加载指的是，调用了defileclass(...)放方法，重新加载字节码、解析、验证。)。而系统默认的appclassloader加载器，他们内部会缓存加载过的class，重新加载的话，就直接取缓存。所与对于热加载的话，只能重新创建一个classloader，然后再去加载已经被加载过的class文件。www.2cto.com

下面看一个class热加载的例子：
代码：hotswapurlclassloader自定义classloader，实现热替换的关键
  1 package testjvm.testclassloader;
  2
  3 import java.io.file;
  4 import java.io.filenotfoundexception;
  5 import java.net.malformedurlexception;
  6 import java.net.url;
  7 import java.net.urlclassloader;
  8 import java.util.hashmap;
  9 import java.util.map;
 10
 11 /**
 12  * 只要功能是重新加载更改过的.class文件，达到热替换的作用
 13  * @author banana
 14  */
 15 public class hotswapurlclassloader extends urlclassloader {
 16     //缓存加载class文件的最后最新修改时间
 17     public static map cachelastmodifytimemap = new hashmap();
 18     //工程class类所在的路径
 19     public static string projectclasspath = "d:/ecpworkspace/zjob-note/bin/";
 20     //所有的测试的类都在同一个包下
 21     public static string packagepath = "testjvm/testclassloader/";
 22    
 23     private static hotswapurlclassloader hcl = new hotswapurlclassloader();
 24    
 25     public hotswapurlclassloader() {
 26         //设置classloader加载的路径
 27         super(getmyurls());
 28     }
 29    
 30     public static hotswapurlclassloader  getclassloader(){
 31         return hcl;
 32     }
 33
 34     private static  url[] getmyurls(){
 35         url url = null;
 36         try {
 37             url = new file(projectclasspath).touri().to;
 38         } catch (malformedurlexception e) {
 39             e.printstacktrace();
 40         }
 41         return new url[] { url };
 42     }
 43    
 44     /**
 45      * 重写loadclass，不采用双亲委托机制("java."开头的类还是会由系统默认classloader加载)
 46      */
 47     @override
 48     public class loadclass(string name,boolean resolve) throws classnotfoundexception {
 49         class clazz = null;
 50         //查看hotswapurlclassloader实例缓存下，是否已经加载过class
 51         //不同的hotswapurlclassloader实例是不共享缓存的
 52         clazz = findloadedclass(name);
 53         if (clazz != null ) {
 54             if (resolve){
 55                 resolveclass(clazz);
 56             }
 57             //如果class类被修改过，则重新加载
 58             if (ismodify(name)) {
 59                 hcl = new hotswapurlclassloader();
 60                 clazz = customload(name, hcl);
 61             }
 62             return (clazz);
 63         }
 64
 65         //如果类的包名为"java."开始，则有系统默认加载器appclassloader加载
 66         if(name.startswith("java.")){
 67             try {
 68                 //得到系统默认的加载cl，即appclassloader
 69                 classloader system = classloader.getsystemclassloader();
 70                 clazz = system.loadclass(name);
 71                 if (clazz != null) {
 72                     if (resolve)
 73                         resolveclass(clazz);
 74                     return (clazz);
 75                 }
 76             } catch (classnotfoundexception e) {
 77                 // ignore
 78             }
 79         }
 80        
 81         return customload(name,this);
 82     }
 83
 84     public class load(string name) throws exception{
 85         return loadclass(name);
 86     }
 87
 88     /**
 89      * 自定义加载
 90      * @param name
 91      * @param cl
 92      * @return
 93      * @throws classnotfoundexception
 94      */
 95     public class customload(string name,classloader cl) throws classnotfoundexception {
 96         return customload(name, false,cl);
 97     }
 98
 99     /**
100      * 自定义加载
101      * @param name
102      * @param resolve
103      * @return
104      * @throws classnotfoundexception
105      */
106     public class customload(string name, boolean resolve,classloader cl)
107             throws classnotfoundexception {
108         //findclass()调用的是urlclassloader里面重载了classloader的findclass()方法
109         class clazz = ((hotswapurlclassloader)cl).findclass(name);
110         if (resolve)
111             ((hotswapurlclassloader)cl).resolveclass(clazz);
112         //缓存加载class文件的最后修改时间
113         long lastmodifytime = getclasslastmodifytime(name);
114         cachelastmodifytimemap.put(name,lastmodifytime);
115         return clazz;
116     }
117    
118     public class loadclass(string name) throws classnotfoundexception {
119         return loadclass(name,false);
120     }
121    
122     @override
123     protected class findclass(string name) throws classnotfoundexception {
124         // todo auto-generated method stub
125         return super.findclass(name);
126     }
127    
128     /**
129      * @param name
130      * @return .class文件最新的修改时间
131      */
132     private long getclasslastmodifytime(string name){
133         string path = getclasscompletepath(name);
134         file file = new file(path);
135         if(!file.exists()){
136             throw new runtimeexception(new filenotfoundexception(name));
137         }
138         return file.lastmodified();
139     }
140    
141     /**
142      * 判断这个文件跟上次比是否修改过
143      * @param name
144      * @return
145      */
146     private boolean ismodify(string name){
147         long lastmodify = getclasslastmodifytime(name);
148         long previousmodifytime = cachelastmodifytimemap.get(name);
149         if(lastmodify>previousmodifytime){
150             return true;
151         }
152         return false;
153     }
154    
155     /**
156      * @param name
157      * @return .class文件的完整路径 (e.g. e:/a.class)
158      */
159     private string getclasscompletepath(string name){
160         string simplename = name.substring(name.lastindexof(".") 1);
161         return projectclasspath packagepath simplename ".class";
162     }
163    
164 }
165

代码：hot被用来修改的类
1 package testjvm.testclassloader;
2
3 public class hot {
4     public void hot(){
5         system.out.println(" version 1 : " this.getclass().getclassloader());
6     }
7 }
8

代码：testhotswap测试类
 1 package testjvm.testclassloader;
 2
 3 import java.lang.reflect.method;
 4
 5 public class testhotswap {
 6
 7     public static void main(string[] args) throws exception {
 8         //开启线程，如果class文件有修改，就热替换
 9         thread t = new thread(new monitorhotswap());
10         t.start();
11     }
12 }
13
14 class monitorhotswap implements runnable {
15     // hot就是用于修改，用来测试热加载
16     private string classname = "testjvm.testclassloader.hot";
17     private class hotclazz = null;
18     private hotswapurlclassloader hotswapcl = null;
19
20     @override
21     public void run() {
22         try {
23             while (true) {
24                 initload();
25                 object hot = hotclazz.newinstance();
26                 method m = hotclazz.getmethod("hot");
27                 m.invoke(hot, null); //打印出相关信息
28                 // 每隔10秒重新加载一次
29                 thread.sleep(10000);
30             }
31         } catch (exception e) {
32             e.printstacktrace();
33         }
34     }
35
36     /**
37      * 加载class
38      */
39     void initload() throws exception {
40         hotswapcl = hotswapurlclassloader.getclassloader();
41         // 如果hot类被修改了，那么会重新加载，hotclass也会返回新的
42         hotclazz = hotswapcl.loadclass(classname);
43     }
44 }

     在测试类运行的时候，修改hot.class文件
hot.class
原来第五行:system.out.println(" version 1 : " this.getclass().getclassloader());
改后第五行:system.out.println(" version 2 : " this.getclass().getclassloader());
  
输出
 version 1 : testjvm.testclassloader.hotswapurlclassloader@610f7612
 version 1 : testjvm.testclassloader.hotswapurlclassloader@610f7612
 version 2 : testjvm.testclassloader.hotswapurlclassloader@45e4d960
 version 2 : testjvm.testclassloader.hotswapurlclassloader@45e4d960
     所以hotswapurlclassloader是重加载了hot类 。注意上面，其实当加载修改后的hot时，hotswapurlclassloader实例跟加载没修改hot的hotswapurlclassloader不是同一个。
图：hotswapurlclassloader加载情况

     总结：上述类热加载，需要自定义classloader，并且只能重新实例化classloader实例，利用新的classloader实例才能重新加载之前被加载过的class。并且程序需要模块化，才能利用这种热加载方式。

二 class卸载
      在java中class也是可以unload。jvm中class和meta信息存放在permgen space区域。如果加载的class文件很多，那么可能导致permgen space区域空间溢出。引起：java.lang.outofmemoryerrorpermgen space.  对于有些class我们可能只需要使用一次，就不再需要了，也可能我们修改了class文件，我们需要重新加载 newclass，那么oldclass就不再需要了。那么jvm怎么样才能卸载class呢。

      jvm中的class只有满足以下三个条件，才能被gc回收，也就是该class被卸载（unload）：
   - 该类所有的实例都已经被gc。
   - 加载该类的classloader实例已经被gc。
   - 该类的java.lang.class对象没有在任何地方被引用。

     gc的时机我们是不可控的，那么同样的我们对于class的卸载也是不可控的。

例子：
代码：simpleurlclassloader，一个简单的自定义classloader
  1 package testjvm.testclassloader;
  2
  3 import java.io.file;
  4 import java.net.malformedurlexception;
  5 import java.net.url;
  6 import java.net.urlclassloader;
  7
  8 public class simpleurlclassloader extends urlclassloader {
  9     //工程class类所在的路径
 10     public static string projectclasspath = "e:/ide/work_place/zjob-note/bin/";
 11     //所有的测试的类都在同一个包下
 12     public static string packagepath = "testjvm/testclassloader/";
 13    
 14     public simpleurlclassloader() {
 15         //设置classloader加载的路径
 16         super(getmyurls());
 17     }
 18    
 19     private static  url[] getmyurls(){
 20         url url = null;
 21         try {
 22             url = new file(projectclasspath).touri().to;
 23         } catch (malformedurlexception e) {
 24             e.printstacktrace();
 25         }
 26         return new url[] { url };
 27     }
 28    
 29     public class load(string name) throws exception{
 30         return loadclass(name);
 31     }
 32
 33     public class loadclass(string name) throws classnotfoundexception {
 34         return loadclass(name,false);
 35     }
 36    
 37     /**
 38      * 重写loadclass，不采用双亲委托机制("java."开头的类还是会由系统默认classloader加载)
 39      */
 40     @override
 41     public class loadclass(string name,boolean resolve) throws classnotfoundexception {
 42         class clazz = null;
 43         //查看hotswapurlclassloader实例缓存下，是否已经加载过class
 44         clazz = findloadedclass(name);
 45         if (clazz != null ) {
 46             if (resolve){
 47                 resolveclass(clazz);
 48             }
 49             return (clazz);
 50         }
 51
 52         //如果类的包名为"java."开始，则有系统默认加载器appclassloader加载
 53         if(name.startswith("java.")){
 54             try {
 55                 //得到系统默认的加载cl，即appclassloader
 56                 classloader system = classloader.getsystemclassloader();
 57                 clazz = system.loadclass(name);
 58                 if (clazz != null) {
 59                     if (resolve)
 60                         resolveclass(clazz);
 61                     return (clazz);
 62                 }
 63             } catch (classnotfoundexception e) {
 64                 // ignore
 65             }
 66         }
 67        
 68         return customload(name,this);
 69     }
 70
 71     /**
 72      * 自定义加载
 73      * @param name
 74      * @param cl
 75      * @return
 76      * @throws classnotfoundexception
 77      */
 78     public class customload(string name,classloader cl) throws classnotfoundexception {
 79         return customload(name, false,cl);
 80     }
 81
 82     /**
 83      * 自定义加载
 84      * @param name
 85      * @param resolve
 86      * @return
 87      * @throws classnotfoundexception
 88      */
 89     public class customload(string name, boolean resolve,classloader cl)
 90             throws classnotfoundexception {
 91         //findclass()调用的是urlclassloader里面重载了classloader的findclass()方法
 92         class clazz = ((simpleurlclassloader)cl).findclass(name);
 93         if (resolve)
 94             ((simpleurlclassloader)cl).resolveclass(clazz);
 95         return clazz;
 96     }
 97    
 98     @override
 99     protected class findclass(string name) throws classnotfoundexception {
100         return super.findclass(name);
101     }
102 }
103

代码：a
1 public class a { 
2 //  public static final level customlevel = new level("test", 550) {}; // 内部类
3 }
代码：testclassunload，测试类
 1 package testjvm.testclassloader;
 2
 3 public class testclassunload {
 4
 5     public static void main(string[] args) throws exception {
 6         simpleurlclassloader loader = new simpleurlclassloader();
 7         // 用自定义的加载器加载a
 8         class clazza = loader.load("testjvm.testclassloader.a");
 9         object a = clazza.newinstance();
10         // 清除相关引用
11         a = null;
12         clazza = null;
13         loader = null;
14         // 执行一次gc垃圾回收
15         system.gc();
16         system.out.println("gc over");
17     }
18 }
19

      运行的时候配置vm参数: -verbose:class；用于查看class的加载与卸载情况。如果用的是eclipse，在run configurations中配置此参数即可。
图:run configurations配置   

输出结果
.....
[loaded java.net.uri$parser from e:\java\jdk1.7.0_03\jre\lib\rt.jar]
[loaded testjvm.testclassloader.a from file:/e:/ide/work_place/zjob-note/bin/]
[unloading class testjvm.testclassloader.a]
gc over
[loaded sun.misc.cleaner from e:\java\jdk1.7.0_03\jre\lib\rt.jar]
[loaded java.lang.shutdown from e:\java\jdk1.7.0_03\jre\lib\rt.jar]
......

blogjava-凯发k8网页登录

com.alibaba.druid.support.spring.stat.druidstatinterceptor是一个标准的spring methodinterceptor。可以灵活进行aop配置。

spring aop的配置文档： 

按类型拦截配置

				  
  
  
    
    
    
        
            druid-stat-interceptor
        
    
  

		

方法名正则匹配拦截配置

				  
  

    
        
            com.mycompany.service.*
            com.mycompany.dao.*
        
    


    


		

有些情况下，可能你需要配置proxy-target-class，例如：

按照beanid来拦截配置

				  
  

    
    
        
            
            xxx-dao
            xxx-service
        
    
    
        
            druid-stat-interceptor
        
    

		

来看atomicinteger提供的接口。

//获取当前的值

public final int get()

//取当前的值，并设置新的值

 public final int getandset(int newvalue)

//获取当前的值，并自增

 public final int getandincrement()

//获取当前的值，并自减

public final int getanddecrement()

//获取当前的值，并加上预期的值

public final int getandadd(int delta)

... ...

下面是一个对比测试，我们写一个synchronized的方法和一个atomicinteger的方法来进行测试，直观的感受下性能上的差异

结果

time elapse:31
time elapse:16
由此不难看出，通过jni本地的cas性能远超synchronized关键字

reference

http://stackoverflow.com/questions/2443239/java-atomicinteger-what-are-the-differences-between-compareandset-and-weakcompar