ddd

src/main/java/com/ekexiu/console/system/dao/DictDao.java

import org.jfw.apt.orm.annotation.dao.method.operator.DeleteWith;
import org.jfw.apt.orm.annotation.dao.method.operator.QueryVal;
import org.jfw.apt.orm.annotation.dao.method.operator.SelectList;
import org.jfw.apt.orm.annotation.dao.method.operator.Update;
import org.jfw.apt.orm.annotation.dao.method.operator.UpdateWith;
import org.jfw.apt.orm.annotation.dao.param.Set;
import org.jfw.apt.orm.core.defaultImpl.StringHandler;
	@SelectList
	List<Dict> queryAlll(Connection con)throws SQLException;
	@Update
	int update(Connection con ,Dict dict)throws SQLException;
	
	@Nullable
	@QueryVal

src/main/java/com/ekexiu/console/system/dao/OrgDao.java

	Organization query(Connection con, String id) throws SQLException;
	@PageSelect
	@OrderBy(" ORDER BY ID")
	@OrderBy(" ORDER BY NAME")
	PageQueryResult<Organization> query(Connection con, @Nullable @Like String name, @Nullable String type, @GtEq @Nullable @Alias("createTime") String bt,
			@LtEq @Nullable @Alias("createTime") String et, int pageSize, int pageNo) throws SQLException;

src/main/java/com/ekexiu/console/system/dao/SysResourceDao.java

import org.jfw.apt.orm.annotation.dao.DAO;
import org.jfw.apt.orm.annotation.dao.method.From;
import org.jfw.apt.orm.annotation.dao.method.OrderBy;
import org.jfw.apt.orm.annotation.dao.method.operator.DeleteWith;
import org.jfw.apt.orm.annotation.dao.method.operator.Insert;
import org.jfw.apt.orm.annotation.dao.method.operator.SelectList;
	@From(SysResource.class)
	int delete(Connection con ,String id)throws SQLException;
	
	@OrderBy("ORDER BY ID ASC")
	@SelectList
	List<SysResource> query(Connection con)throws SQLException;	
	
}

src/main/java/com/ekexiu/console/system/po/Dict.java

	private String code;
	private String caption;
	private String descp;
	private boolean tree;
	private boolean readonly;
	private String item;
	
	public void setReadonly(boolean readonly) {
		this.readonly = readonly;
	}
	@Column(DE.Text_de)
	@Column(value=DE.Text_de,renewable=false)
	public String getItem() {
		return item;
	}
	public void setItem(String item) {
		this.item = item;
	}
	@Column(DE.boolean_de)
	public boolean isTree() {
		return tree;
	}
	public void setTree(boolean tree) {
		this.tree = tree;
	}
	
}

src/main/java/com/ekexiu/console/system/po/SysResource.java

@Table
public class SysResource {
	private String id;
	private String name;
	private String uri;
	private String css;
	private String script;
	public void setType(String type) {
		this.type = type;
	}
	@Column(DE.string_de)
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Column(DE.string_de)
	public String getId() {

src/main/java/com/ekexiu/console/system/service/DictService.java

import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import javax.swing.event.ListSelectionEvent;
import javax.sql.DataSource;
import org.jfw.apt.annotation.Autowrie;
import org.jfw.apt.web.annotation.Path;
import org.jfw.apt.web.annotation.param.PathVar;
import org.jfw.apt.web.annotation.param.RequestBody;
import org.jfw.util.exception.JfwBaseException;
import org.jfw.util.jdbc.JdbcTask;
import org.jfw.util.jdbc.JdbcUtil;
import org.jfw.util.json.JsonService;
import org.jfw.util.reflect.TypeReference;
		ret.addAll(ds);
		return ret;
	}
	
	@Get
	@Path("/code/{code}")
	public DictInfo get(@PathVar String code)
	{
	@Path("/info/{code}")
	public DictInfo get(@PathVar String code) {
		return this.dicts.get().get(code);
	}
	
	
	@Get
	@Path("/item/{code}")
	public List<DictItem> getItems(@PathVar String code) {
		AtomicReference<LinkedList<DictItem>> ref = this.items.get(code);
		return ref != null ? ref.get() : Collections.<DictItem> emptyList();
	}
	@Get
	@Path("/editItem/{code}")
	public List<EditDictItem> getItems(@JdbcConn Connection con, @PathVar String code) throws SQLException {
		DictInfo di = this.dicts.get().get(code);
		if (di == null || di.isReadonly())
			return Collections.<EditDictItem> emptyList();
		String val = this.dictDao.queryItem(con, code);
		if (val == null || val.length() < 3)
			return Collections.<EditDictItem> emptyList();
		return JsonService.fromJson(val, LINKEDLIST_EDITDICTITEM_TYPE);
	}
	@Put
	@Path
	public void update(@JdbcConn(true) Connection con,  @RequestBody List<EditDictItem> items) throws SQLException, JfwBaseException {
		LinkedList<DictItem> ret = new LinkedList<DictItem>();
	//	if()
		
	@Path("/info")
	public void update(@JdbcConn final Connection con, @RequestBody final Dict dict) throws SQLException {
		final AtomicBoolean ab = new AtomicBoolean(false);
		JdbcUtil.executeAutoCommit(con, new JdbcTask() {
			@Override
			public void exec() throws SQLException {
				ab.set(dictDao.update(con, dict) > 0);
			}
		});
		if (ab.get())
			this.update(dict);
	}
	@Put
	@Path("/item/{code}")
	public void update(@JdbcConn(true) final Connection con, @PathVar final String code, @RequestBody List<EditDictItem> items)
			throws SQLException, JfwBaseException {
		DictInfo di = this.dicts.get().get(code);
		if (di == null) {
			throw new JfwBaseException(50001, "invalid parameter code: not exists dict code");
		}
		if (di.isReadonly()) {
			throw new JfwBaseException(50002, "invalid parameter code: readonly dict code");
		}
		// TODO : check dictItem.system == true can't modify
		LinkedList<DictItem> ret = new LinkedList<DictItem>();
		if(di.isTree()){
		if (transfer(items, ret) == null) {
			throw new JfwBaseException(50003, "not exists parentCode or loop parentCode");
		}}else{
			for(ListIterator<EditDictItem> it = items.listIterator();it.hasNext();){
				ret.add(transfer(it.next()));
			}
		}
		final AtomicBoolean ab = new AtomicBoolean(false);
		final String val = JsonService.toJson(items);
		JdbcUtil.executeAutoCommit(con, new JdbcTask() {
			public void exec() throws SQLException {
				if (dictDao.update(con, code, val) > 0)
					ab.set(true);
			}
		});
		if (ab.get()) {
			this.items.get(code).set(ret);
		}
	}
	// public static List
		}
		return null;
	}
	
	public LinkedList<DictItem> transfer(List<EditDictItem> src, LinkedList<DictItem> dest) {
		Map<String, EditDictItem> map = new HashMap<String, EditDictItem>();
				return null;
			}
		}
		// while(map.size()>0){
		// boolean added = false;
		// for(Map.Entry<String,EditDictItem> entry:map.entrySet()){
		// String code = entry.getKey();
		// EditDictItem eitem = entry.getValue();
		// String pc =eitem.getParentCode();
		// if(pc ==null || pc.length()==0){
		// added = true;
		// map.remove(code);
		// dest.add(transfer(eitem));
		// break;
		// }else{
		// DictItem item = query(dest,pc);
		// if(item!=null){
		// added=true;
		// item.getChildren().add(transfer(eitem));
		// map.remove(code);
		// break;
		// }
		// }
		// }
		// if(!added) break;
		// }
		// return dest;
	}
	public DictItem transfer(EditDictItem eitem) {
			if (null == transfer(list, ret)) {
				// TODO:: // log not exists parentCode or loop parentCode
			} 
			}
		} catch (Exception e) {
			// TODO: ///// log json parse exception
		return ret;
	}
	public void initByDataSource(DataSource ds) throws SQLException {
		final Connection con = ds.getConnection();
		JdbcUtil.executeAutoClose(con, new JdbcTask() {
			@Override
			public void exec() throws SQLException {
				List<Dict> list = DictService.this.dictDao.queryAlll(con);
				DictService.this.init(list);
			}
		}, false);
	}
	private synchronized void init(List<Dict> list) {
		if(null!= this.dicts.get()) return;		
		if (null != this.dicts.get())
			return;
		Map<String, DictInfo> map = new HashMap<String, DictInfo>();
		for (Dict dict : list) {
			map.put(dict.getCode(), new DictInfo(dict));
		map.put(dict.getCode(), new DictInfo(dict));
		this.dicts.set(map);
	}
	
	
}

src/main/java/com/ekexiu/console/system/service/RightService.java

import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;
import javax.sql.DataSource;
import org.jfw.apt.annotation.Autowrie;
import org.jfw.apt.orm.annotation.dao.method.operator.Delete;
import org.jfw.apt.web.annotation.param.JdbcConn;
import org.jfw.apt.web.annotation.param.PathVar;
import org.jfw.apt.web.annotation.param.RequestBody;
import org.jfw.util.jdbc.JdbcTask;
import org.jfw.util.jdbc.JdbcUtil;
import com.ekexiu.console.system.dao.RightDao;
import com.ekexiu.console.system.po.SysRight;
@Path("/sys/right")
public class RightService {
	private AtomicReference<Map<Integer, SysRight>> rights = new AtomicReference<Map<Integer, SysRight>>();
	@Autowrie
	private RightDao rightDao;
	public void setRightDao(RightDao rightDao) {
		this.rightDao = rightDao;
	}
	
	
	@Get
	@Path("/all")
	public List<SysRight> query(@JdbcConn Connection con) throws SQLException {
		return this.rightDao.query(con);
	public Collection<SysRight> query() throws SQLException {
		return this.rights.get().values();
	}
	@Get
	@Path("/type/{type}")
	public List<SysRight> queryByType(@JdbcConn Connection con, @PathVar String type) throws SQLException {
		return this.rightDao.query(con, type);
	public List<SysRight> queryByType(@PathVar String type) throws SQLException {
		ArrayList<SysRight> list = new ArrayList<SysRight>();
		for (SysRight right : this.query()) {
			if (type.equals(right.getType()))
				list.add(right);
		}
		return list;
	}
	@Get
	@Path("/id/{id}")
	public SysRight queryById(@JdbcConn Connection con, @PathVar int id) throws SQLException {
		return this.rightDao.query(con, id);
		return this.rights.get().get(id);
	}
	@Post
	@Path()
	public void insert(@JdbcConn(true) Connection con, SysRight right) throws SQLException {
		this.rightDao.insert(con, right);
	public void insert(@JdbcConn final Connection con, final SysRight right) throws SQLException {
		JdbcUtil.executeAutoCommit(con, new JdbcTask() {
			@Override
			public void exec() throws SQLException {
				rightDao.insert(con, right);
			}
		});
		this.update(right);
	}
	@Put
	@Path()
	public void update(@JdbcConn(true) Connection con, @RequestBody SysRight right) throws SQLException {
		this.rightDao.insert(con, right);
	public void update(@JdbcConn final Connection con, @RequestBody final SysRight right) throws SQLException {
		final AtomicReference<Boolean> ab = new AtomicReference<Boolean>(false);
		JdbcUtil.executeAutoCommit(con, new JdbcTask() {
			@Override
			public void exec() throws SQLException {
				ab.set(rightDao.update(con, right)>0);
			}
		});
		if(ab.get())this.update(right);
	}
	@Path("/{id}")
	@Delete
	public void delete(@JdbcConn(true) Connection con, @PathVar int id) throws SQLException {
		this.rightDao.delete(con, id);
	public void delete(@JdbcConn final Connection con, @PathVar final int id) throws SQLException {
		final AtomicReference<Boolean> ab = new AtomicReference<Boolean>(false);
		JdbcUtil.executeAutoCommit(con, new JdbcTask() {
			@Override
			public void exec() throws SQLException {
				ab.set(rightDao.delete(con, id)>0);
			}
		});
		if(ab.get())this.remove(id);
	}
	public void initByDataSource(DataSource ds) throws SQLException {
		final Connection con = ds.getConnection();
		JdbcUtil.executeAutoClose(con, new JdbcTask() {
			@Override
			public void exec() throws SQLException {
				List<SysRight> list =rightDao. query(con);
				Map<Integer, SysRight> map = new HashMap<Integer, SysRight>();
				for (SysRight right : list) {
					map.put(right.getId(), right);
				}
				rights.set(map);
			}
		}, false);
	}
	private void update(SysRight right) {
		Map<Integer, SysRight> map = new HashMap<Integer, SysRight>();
		map.putAll(rights.get());
		map.remove(right.getId());
		map.put(right.getId(), right);
		rights.set(map);
	}
	private void remove(int rightId) {
		Map<Integer, SysRight> map = new HashMap<Integer, SysRight>();
		map.putAll(rights.get());
		map.remove(rightId);
		rights.set(map);
	}
}

src/main/java/com/ekexiu/console/system/service/RoleService.java

import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import javax.sql.DataSource;
import org.jfw.apt.annotation.Autowrie;
import org.jfw.apt.web.annotation.Path;
import org.jfw.apt.web.annotation.param.RequestBody;
import org.jfw.util.StringUtil;
import org.jfw.util.auth.AuthUtil;
import org.jfw.util.jdbc.JdbcTask;
import org.jfw.util.jdbc.JdbcUtil;
import com.ekexiu.console.system.dao.RoleDao;
import com.ekexiu.console.system.dao.UserRoleDao;
@Path("/sys/role")
public class RoleService {
	
	public static final String EMPTY_AUTH_STR = AuthUtil.serialAuth(new int[]{0});
	
	public static final String EMPTY_AUTH_STR = AuthUtil.serialAuth(new int[] { 0 });
	private AtomicReference<Map<String, ConsoleAuthRole>> cacheRoles = new AtomicReference<Map<String, ConsoleAuthRole>>();
	@Autowrie
	private RoleDao roleDao;
	@Autowrie
	public void setRoleDao(RoleDao roleDao) {
		this.roleDao = roleDao;
	}
	
	
	
	@Post
	@Path
	public void insert(@JdbcConn(true) Connection con,ConsoleAuthRole role)throws SQLException{
		Role r = new Role();
		r.setId(StringUtil.buildUUID());
	public void insert(@JdbcConn final Connection con, ConsoleAuthRole role) throws SQLException {
		String id = StringUtil.buildUUID();
		role.setId(id);
		final Role r = new Role();
		r.setId(id);
		r.setName(role.getName());
		r.setDescp(role.getDescp());
		int[] auths = role.getAuths();
		if(auths==null || auths.length==0){
		if (auths == null || auths.length == 0) {
			r.setAuthinfo(EMPTY_AUTH_STR);
		}else{
		} else {
			r.setAuthinfo(AuthUtil.serialAuth(AuthUtil.compress(auths)));
		}
		this.roleDao.insert(con, r);
		JdbcUtil.executeAutoCommit(con, new JdbcTask() {
			@Override
			public void exec() throws SQLException {
				roleDao.insert(con, r);
			}
		});
		this.update(role);
	}
	@Put
	@Path
	public void update(@JdbcConn(true) Connection con,@RequestBody ConsoleAuthRole role)throws SQLException{
		Role r = new Role();
		r.setName(role.getName());
		r.setDescp(role.getDescp());
		int[] auths = role.getAuths();
		if(auths==null || auths.length==0){
			r.setAuthinfo(EMPTY_AUTH_STR);
		}else{
			r.setAuthinfo(AuthUtil.serialAuth(AuthUtil.compress(auths)));
		}
		this.roleDao.update(con, r);
	public void update(@JdbcConn final Connection con, @RequestBody final ConsoleAuthRole role) throws SQLException {
		final AtomicBoolean ab = new AtomicBoolean(false);
		JdbcUtil.executeAutoCommit(con, new JdbcTask() {
			@Override
			public void exec() throws SQLException {
				Role r = new Role();
				r.setName(role.getName());
				r.setDescp(role.getDescp());
				int[] auths = role.getAuths();
				if (auths == null || auths.length == 0) {
					r.setAuthinfo(EMPTY_AUTH_STR);
				} else {
					r.setAuthinfo(AuthUtil.serialAuth(AuthUtil.compress(auths)));
				}
				ab.set(roleDao.update(con, r) > 0);
			}
		});
		if (ab.get())
			this.update(role);
	}
	
	@Path("/{id}")
	@Delete
	public void delete(@JdbcConn(true) Connection con,@PathVar String id)throws SQLException{
		 this.userRoleDao.deleteByRoleId(con, id);		 
		 this.roleDao.delete(con, id);
	public void delete(@JdbcConn final Connection con, @PathVar final String id) throws SQLException {
		final AtomicBoolean ab = new AtomicBoolean(false);
		JdbcUtil.executeAutoCommit(con, new JdbcTask() {
			@Override
			public void exec() throws SQLException {
				userRoleDao.deleteByRoleId(con, id);
				ab.set(roleDao.delete(con, id) > 0);
			}
		});
		if (ab.get())
			this.remove(id);
	}
	
	@Path("/all")
	@Get
	public List<ConsoleAuthRole> queryAll(@JdbcConn Connection con)throws SQLException{
		List<Role> roles= this.roleDao.query(con);
		ArrayList<ConsoleAuthRole> ret = new ArrayList<ConsoleAuthRole>(roles.size());
		for(ListIterator<Role> it = roles.listIterator(); it.hasNext();){
			ret.add(conver(it.next()));
		}
		return ret;
	public Collection<ConsoleAuthRole> queryAll() throws SQLException {
		return this.cacheRoles.get().values();
	}
	@Path("/id/{id}")
	@Get
	public ConsoleAuthRole queryById(@JdbcConn Connection con ,@PathVar String id ) throws SQLException{
	  return conver(this.roleDao.query(con, id));
	public ConsoleAuthRole queryById(@PathVar String id) throws SQLException {
		return this.cacheRoles.get().get(id);
	}
	@Path("/byUserid/{userid}")
	@Get
	public List<ConsoleAuthRole> queryByUserId(@JdbcConn Connection con,@PathVar String userid)throws SQLException{
		List<Role> roles= this.roleDao.queryByUser(con, userid);
	public List<ConsoleAuthRole> queryByUserId(@JdbcConn Connection con, @PathVar String userid) throws SQLException {
		List<Role> roles = this.roleDao.queryByUser(con, userid);
		ArrayList<ConsoleAuthRole> ret = new ArrayList<ConsoleAuthRole>(roles.size());
		for(ListIterator<Role> it = roles.listIterator(); it.hasNext();){
		for (ListIterator<Role> it = roles.listIterator(); it.hasNext();) {
			ret.add(conver(it.next()));
		}
		return ret;
	}
	
	
	
	
	
	
	
	
	public static ConsoleAuthRole conver(Role role){
		if(null == role) return null;
	public static ConsoleAuthRole conver(Role role) {
		if (null == role)
			return null;
		ConsoleAuthRole cr = new ConsoleAuthRole();
		cr.setDescp(role.getDescp());
		cr.setId(role.getId());
		cr.setAuths(AuthUtil.unCompress(AuthUtil.deSerialAuth(role.getAuthinfo())));
		return cr;
	}
	public void initByDataSource(DataSource ds) throws SQLException {
		final Connection con = ds.getConnection();
		JdbcUtil.executeAutoClose(con, new JdbcTask() {
			@Override
			public void exec() throws SQLException {
				List<Role> list = roleDao.query(con);
				Map<String, ConsoleAuthRole> map = new HashMap<String, ConsoleAuthRole>();
				for (Role role : list) {
					ConsoleAuthRole car = conver(role);
					map.put(car.getId(), car);
				}
				cacheRoles.set(map);
			}
		}, false);
	}
	private void update(ConsoleAuthRole car) {
		Map<String, ConsoleAuthRole> map = new HashMap<String, ConsoleAuthRole>();
		map.putAll(cacheRoles.get());
		map.remove(car.getId());
		map.put(car.getId(), car);
		cacheRoles.set(map);
	}
	private void remove(String id) {
		Map<String, ConsoleAuthRole> map = new HashMap<String, ConsoleAuthRole>();
		map.putAll(cacheRoles.get());
		map.remove(id);
		cacheRoles.set(map);
	}
}

src/main/java/com/ekexiu/console/system/service/SysResourceService.java

import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import javax.sql.DataSource;
import org.jfw.apt.annotation.Autowrie;
import org.jfw.apt.web.annotation.LoginUser;
import org.jfw.apt.web.annotation.operate.Put;
import org.jfw.apt.web.annotation.param.JdbcConn;
import org.jfw.apt.web.annotation.param.PathVar;
import org.jfw.util.jdbc.JdbcTask;
import org.jfw.util.jdbc.JdbcUtil;
import com.ekexiu.console.system.dao.SysResourceDao;
import com.ekexiu.console.system.po.SysResource;
@Path("/sys/resource")
public class SysResourceService {
	
	private AtomicReference<Map<String, SysResource>> cache = new AtomicReference<Map<String, SysResource>>();
	@Autowrie
	private SysResourceDao sysResourceDao;
	public void setSysResourceDao(SysResourceDao sysResourceDao) {
		this.sysResourceDao = sysResourceDao;
	}
	
	@Get
	@Path("/all")
	public List<SysResource> query(@JdbcConn Connection con)throws SQLException{
		return this.sysResourceDao.query(con);
	public Collection<SysResource> query() throws SQLException {
		return this.cache.get().values();
	}
	
	@Post
	@Path
	public void insert(@JdbcConn(true) Connection con,SysResource sres)throws SQLException{
		this.sysResourceDao.insert(con, sres);
	public void insert(@JdbcConn(true) final Connection con, final SysResource sres) throws SQLException {
		JdbcUtil.executeAutoCommit(con, new JdbcTask() {
			@Override
			public void exec() throws SQLException {
				sysResourceDao.insert(con, sres);
			}
		});
		this.update(sres);
	}
	
	@Put
	@Path
	public void update(@JdbcConn(true) Connection con,SysResource sres) throws SQLException{
		this.sysResourceDao.update(con, sres);
	public void update(@JdbcConn(true) final Connection con, final SysResource sres) throws SQLException {
		final AtomicBoolean ab = new AtomicBoolean(false);
		JdbcUtil.executeAutoCommit(con, new JdbcTask() {
			@Override
			public void exec() throws SQLException {
				ab.set(sysResourceDao.update(con, sres) > 0);
			}
		});
		if (ab.get())
			this.update(sres);
	}
	@Delete
	@Path("/{id}")
	public void delete(@JdbcConn(true) Connection con ,@PathVar String id)throws SQLException{
		this.sysResourceDao.delete(con, id);
	@Path("/id/{id}")
	public void delete(@JdbcConn(true) final Connection con, @PathVar final String id) throws SQLException {
		final AtomicBoolean ab = new AtomicBoolean(false);
		JdbcUtil.executeAutoCommit(con, new JdbcTask() {
			@Override
			public void exec() throws SQLException {
				ab.set(sysResourceDao.delete(con, id) > 0);
			}
		});
		if (ab.get())
			this.remove(id);
	}
	
	@Get
	@Path("/byLoginUser")
	public List<SysResource> query(@JdbcConn Connection con,@LoginUser ConsoleAuthUser user )throws SQLException{
	@Path("/user")
	public List<SysResource> query(@JdbcConn Connection con, @LoginUser ConsoleAuthUser user) throws SQLException {
		List<SysResource> ret = new ArrayList<SysResource>();
		for(SysResource res:this.query(con)){
			if(user.hasAuthority(res.getAuthRight())){
		for (SysResource res :this.cache.get().values()) {
			if (user.hasAuthority(res.getAuthRight())) {
				ret.add(res);
			}
		}
		return ret;
	}
	public void initByDataSource(DataSource ds) throws SQLException {
		final Connection con = ds.getConnection();
		JdbcUtil.executeAutoClose(con, new JdbcTask() {
			@Override
			public void exec() throws SQLException {
				List<SysResource> list = sysResourceDao.query(con);
				Map<String, SysResource> map = new HashMap<String, SysResource>();
				for (SysResource res : list) {
					map.put(res.getId(), res);
				}
				cache.set(map);
			}
		}, false);
	}
	private void update(SysResource res) {
		Map<String, SysResource> map = new HashMap<String, SysResource>();
		map.putAll(cache.get());
		map.remove(res.getId());
		map.put(res.getId(), res);
		cache.set(map);
	}
	private void remove(String id) {
		Map<String, SysResource> map = new HashMap<String, SysResource>();
		map.putAll(cache.get());
		map.remove(id);
		cache.set(map);
	}
}

src/main/java/com/ekexiu/console/system/service/UserConfigService.java

import java.lang.reflect.Type;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.jfw.apt.annotation.Autowrie;
import org.jfw.util.reflect.TypeReference;
import com.ekexiu.console.system.dao.UserConfigDao;
import com.ekexiu.console.system.po.SysResource;
import com.ekexiu.console.system.po.UserConfig;
import com.ekexiu.console.system.vo.ConsoleAuthUser;
import com.ekexiu.console.system.vo.UserMenu;
	@Autowrie
	private UserConfigDao userConfigDao;
	@Autowrie
	private SysResourceService sysResourceService;
	public SysResourceService getSysResourceService() {
		return sysResourceService;
	}
	public void setSysResourceService(SysResourceService sysResourceService) {
		this.sysResourceService = sysResourceService;
	}
	public UserConfigDao getUserConfigDao() {
		return userConfigDao;
	@Get
	@Path("/menu")
	public List<UserMenu> menu(@JdbcConn Connection con,@LoginUser() ConsoleAuthUser user)throws SQLException{
		List<UserMenu> ret = this.load(con,user.getId(),"menu",MENU_TYPE);
		if(null==ret){
			//TODO: impl load default
	public List<UserMenu> menu(@JdbcConn Connection con, @LoginUser() ConsoleAuthUser user) throws SQLException {
		List<UserMenu> ret = this.load(con, user.getId(), "menu", MENU_TYPE);
		if (null == ret || ret.isEmpty()) {
			ret = new ArrayList<UserMenu>();
			List<SysResource> reses = this.sysResourceService.query(con, user);
			for (SysResource res : reses) {
				if (res.isMain())
					ret.add(transfer(res));
			}
		}
		//TODO: test del trigger deploy
		return	 JsonService.fromJson("[{\"caption\":\"组织机构\",\"children\":[{\"caption\":\"机构管理\",\"res\":\"sys_org_index\"}]}]", MENU_TYPE);
		return ret;
	}
	public UserMenu transfer(SysResource res) {
		UserMenu menu = new UserMenu();
		menu.setCaption(res.getName());
		menu.setModal(false);
		menu.setRes(res.getId());
		return menu;
	}
}

src/main/java/com/ekexiu/console/system/vo/DictInfo.java

	private String caption;
	private String descp;
	private boolean readonly;
	private boolean tree;
	
	
	
		this.caption = dict.getCaption();
		this.descp = dict.getDescp();
		this.readonly = dict.isReadonly();
		this.tree = dict.isTree();
	}
	public String getCode() {
		return code;
	public void setReadonly(boolean readonly) {
		this.readonly = readonly;
	}
	public boolean isTree() {
		return tree;
	}
	public void setTree(boolean tree) {
		this.tree = tree;
	}
	
	
}

src/main/java/com/ekexiu/console/util/GlobalInitBean.java

package com.ekexiu.console.util;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.concurrent.ScheduledExecutorService;
import javax.sql.DataSource;
import org.jfw.util.bean.AfterBeanFactory;
import org.jfw.util.bean.BeanFactory;
import org.jfw.util.context.JfwAppContext;
import com.ekexiu.console.system.service.DictService;
import com.ekexiu.console.system.service.RightService;
import com.ekexiu.console.system.service.RoleService;
import com.ekexiu.console.system.service.SysResourceService;
public class GlobalInitBean implements AfterBeanFactory {
	private DataSource dataSource;
	private ScheduledExecutorService service;
	private BeanFactory beanf;
	
	
	public BeanFactory getBeanf() {
		return beanf;
	}
	public void setBeanf(BeanFactory beanf) {
		this.beanf = beanf;
	}
	public DataSource getDataSource() {
		return dataSource;
	}
	public void setDataSource(DataSource dataSource) {
		this.dataSource = dataSource;
	}
	public ScheduledExecutorService getService() {
		return service;
	}
	public void setService(ScheduledExecutorService service) {
		this.service = service;
	}
	@Override
	public void handle(BeanFactory bf) throws Throwable {
		this.beanf = bf;
		this.service = JfwAppContext.getScheduledExecutorService();
		this.dataSource = (DataSource) bf.getBean("dataSource");
		for(ListIterator<Initable> it= this.loadInitables().listIterator() ; it.hasNext();){
			it.next().init(this);
		}
	}
	
	public List<Initable> loadInitables()throws Exception{
		LinkedList<Initable> list = new LinkedList<Initable>();
		list.add(new Initable() {			
			@Override
			public void init(GlobalInitBean gib) throws Exception {
				getBean(DictService.class).initByDataSource(dataSource);
			}
		});
		list.add(new Initable() {			
			@Override
			public void init(GlobalInitBean gib) throws Exception {
				getBean(RightService.class).initByDataSource(dataSource);
			}
		});
		list.add(new Initable() {			
			@Override
			public void init(GlobalInitBean gib) throws Exception {
				getBean(RoleService.class).initByDataSource(dataSource);
			}
		});
		list.add(new Initable() {			
			@Override
			public void init(GlobalInitBean gib) throws Exception {
				getBean(SysResourceService.class).initByDataSource(dataSource);
			}
		});
		return list;
	}
	public <T> T getBean(Class<T> cls){
		return this.beanf.getBean(classNameToBeanName(cls), cls);
	}
	public static String classNameToBeanName(Class<?> cls){
		return cls.getName().replaceAll("\\.","_");
	}
	
	public static void main(String[] args){
		System.out.println(classNameToBeanName(GlobalInitBean.class));
	}
}

src/main/java/com/ekexiu/console/util/Initable.java

package com.ekexiu.console.util;
public interface Initable {
	void init(GlobalInitBean gib)throws Exception; 
}

src/main/webapp/WEB-INF/web.xml

      <param-name>configFileName</param-name>
      <param-value>beanConfig.properties,${main.config}</param-value>
    </init-param>
<!--     <init-param>
  <init-param>
    	<param-name>afterBeanFactory</param-name>
    	<param-value>com.ekexiu.portal.job.SchJob,com.ekexiu.portal.job.TaskJob</param-value>
    </init-param> -->
    	<param-value>com.ekexiu.console.util.GlobalInitBean</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>