.insert into B (id,a,b,c)
select id,a,b,c from A
2.线程和进程的差异:进程便是一个可实行程序,一个线程可以有多个线程
3.接口和抽象类的差异
抽象类：可有又布局方法，可以有普通成员方法，方法可以是抽象的或者非抽象的，方法的访问类型可以是public和protected，可以包含静态方法，成员变量可以利用任意变量，一个类只能继续一个抽象类，可以实当代码重用
接口：不能有布局方法，没有普通成员方法，方法必须是抽象的，不能包含静态方法，成员变量必须final润色，一个类可以实现多个接口。
4 库存什么时候减的：用户将商品加入购物车并付款往后。
5. 分布式用的什么，dubbo用什么实现的，对dubbo理解吗：
a)Dubbo，Redis
b)做事容器卖力启动，加载，运行做事供应者
做事供应者在启动时，想注册中央注书籍身供应的做事
做事消费者在启动时，向注册中央订阅自己所需的做事
注册中央返回做事供应者地址列表给消费者，如果有变更，注册中央将基于长连接推送变更数据给消费者。
做事消费者，从消费者地址列表中，基于负载均衡算法，西安一台供应者进行调用，如果调用失落败，再选一台调用
做事消费者和供应者，在内存中累计调用次数和调用韶光，定时每分钟发送一次统计数据到监控中央。
6. 做事器用了几台：13台
7. 后台页面能自己写吗，easyUi常用控件，常用方法：
a)Form表单控件，layout布局控件，gird控件
b)Datagrid动态列，访问url获取数据，弹出模态框，数据表格
前台页面都是jsp吗
首页用的html
8. Jsp的核心及核心标签
a)Servlet
b)Core XML Database Functions
9.Servlet生命周期
a)初始化阶段 调用init()方法
b)相应客户要求阶段 调用service()方法
c)终止阶段 调用destroy()方法
8. Redis什么情形下利用，redis持久化方案
a)处理大数据量的时候
b)Redis的所有数据都是保存在内存中，
Rdb：快照形式，定期把内存中当前时候的数据保存到磁盘，redis默认支持的持久化方案
aof形式：append only file。把所有对redis数据库操作的命令，增编削操作命令，保存到文件中，数据库规复是把所有命令实行一遍即可。
10.SpringMVC 和Struts2有差异
a)Struts2是类级别拦截器，一个类对应一个request高下文；
SpringMVC是方法级别的拦截，一个方法对应一个request高下文。
b)Struts2须要对每个request进行封装，比较花费内存
c)拦截器实现机制上，Struts2有自己的interceptor机制，springMVC用的是独立的aop办法
d)SpringMVC的入口是servlet，而Struts2的入口是filter
e)SpringMVC集成了Ajax利用非常方便，只须要表明@ResponseBody就可以实现
f)SpringMVC和Spring是无缝的，从项目管理和安全性上比Struts2高
g)Spring开拓效率和性能高于Struts
11. Hibernate和Mybatis的差异亲睦坏
a)Sql优化方面：hibernate的查询会将表中所有的字段查询出来，这一点会有性能的花费
Mybatis的sql是手动编写的，以是可以按需求指定查询的字段，sql会更灵巧，可控性更好
b)Hibernate是在JDBC上进行了一次封装
Mybatis是基于原生的JDBC，运行速率有上风
c)Mybatis mapper xml支持动态sql；Hibernate不支持
d)Hibernate与详细数据库的关联只需在xml文件中配置即可，所有hql语句与详细的数据库无关，移植性好
Mybatis项目所有的sql语句都是依赖所用的数据库的，以是不同数据库类型的支持不好
12.Hibernate映射关系
a)单向一对一关联映射
b)单向一对多关联映射
c)单向多对一关联映射
d)单向多对多关联映射
13.Spring的理解，如何依赖注入
a)Spring是一个轻量级的掌握反转和面向切面的容器框架
b)Spring使得工具管理集中化和大略化
c)依赖注入类型：setter注入和布局方法注入
setter injection工具被创建后将被依赖工具通过set方法设置进去
constructor injection工具创建时被依赖工具以布局方法参数的办法注入
d)Spring核心功能：
BeanFactory：产生一个新的实例，可以实现单例模式，是核心容器的紧张组件，是工厂模式的实现。
BeanWraper：供应统一的get及set方法
ApplicationContext：供应框架的实现，包括BeanFactory的所有功能
14.口试思想
OOA是面向工具的剖析 Analysis
OOD是面向工具的设计 Design
OOP是面向工具的编程 Programming
都是相辅相成的: 剖析是为了设计，设计是为了编程。
都属于软件工程的不同课题
16.Dubbo协议：采取NIO复用单一长连接，并利用线程池并发处理要求，减少握手和加大并发效率，在大文件传输时，单持续接会成为瓶颈
为表设置索引要付出代价的：一是增加了数据库的存储空间，二是在插入和修正数据时要花费较多的韶光(由于索引也要随之变动)
Dubbo缺省协议采取单一长连接和NIO异步通讯，适宜于小数据量大并发的做事调用，以及做事消费者机器数远大于做事供应者机器数的情形。
索引是对数据库表中一个或多个列（例如，employee 表的姓名 (name) 列）的值进行排序的构造。如果想按特定职员的姓来查找他或她，则与在表中搜索所有的行比较，索引有助于更快地获取信息。
例如这样一个查询：select from table1 where id=10000。如果没有索引，必须遍历全体表，直到ID即是10000的这一行被找到为止；有了索引之后(必须是在ID这一列上建立的索引)，即可在索引中查找。由于索引是经由某种算法优化过的，因而查找次数要少的多。可见，索引是用来定位的。
相称于对指定的列天生目录啊，可以加快查找速率，对读多写少的列，可以添加索引
RPC（Remote Procedure Call）是一种远程调用协议，大略地说便是能使运用像调用本地方法一样的调用远程的过程或做事，可以运用在分布式做事、分布式打算、远程做事调用等许多场景。提及 RPC 大家并不陌生，业界有很多开源的精良 RPC 框架，例如 Dubbo、Thrift、gRPC、Hprose 等等。
17
上面是直坨数字阵型
18.
19.
20.SQL语句优化策略
阅读( )暂无评论韶光：2014-03-10 18:06:32
总体来说，SQL语句优化策略有以下几个方面：
● 创建表的时候。应只管即便建立主键,根据主键查询数据；
● 大数据表删除，用truncate table代替delete。
● 合理利用索引，在OLTP运用中一张表的索引不要太多。组合索引的列顺序只管即便与查询条件列顺序保持同等；对付数据操作频繁的表，索引须要定期重修，以减少失落效的索引和碎片。
● 查询只管即便用确定的列名，少用号。
只管即便少嵌套子查询，这种查询会花费大量的CPU资源；对付有比较多
or运算的查询，建议分成多个查询，用union all联结起来；多表查询
的查询语句中，选择最有效率的表名顺序(基于规则的优化器中有效)。Oracle解析器对表解析从右到左，以是记录少的表放在右边。
● 只管即便多用commit语句提交事务，可以及时开释资源、解
锁、开释日志空间、减少管理花费；在频繁的、性能哀求比较高的
数据操作中，只管即便避免远程访问，如数据库链等，访问频繁的表可
以常驻内存：alter table．．．cache；
详细分来：
1)、只管即便少用IN操作符，基本上所有的IN操作符都可以用EXISTS代替。
2)、不用NOT IN操作符，可以用NOT EXISTS或者外连接+（外连接+判断为空）替代。
3)、不用“<>”或者“!=”操作符。对不即是操作符的处理会造玉成表扫描，可以用“<” or “>”代替。例如：a<>0 改为 a>0 or a<0，a<>’ ’ 改为 a>’ ’
4)、Where子句中涌现IS NULL或者IS NOT NULL时，Oracle会停滞利用索引而实行全表扫描。可以考虑在设计表时，对索引列设置为NOT NULL。这样就可以用其他操作来取代判断NULL的操作。
5)、当通配符“%”或者“_”作为查询字符串的第一个字符时，索引不会被利用，因此一样平常不要作为第一个字符涌现。
6)、对付有连接的列“||”，末了一个连接列索引会无效。只管即便避免连接，可以分开连接或者利用不浸染在列上的函数替代。
7)、如果索引不是基于函数的，那么当在Where子句中对索引列利用函数时，索引不中兴浸染。
8)、Where子句中避免在索引列上利用打算，否则将导致索引失落效而进行全表扫描。
9)、对数据类型不同的列进行比较时，会使索引失落效。
10)、用“>=”替代“>”。
11)、UNION操作符会对结果进行筛选，肃清重复，数据量大的情形下可能会引起磁盘排序。如果不须要删除重复记录，该当利用UNION ALL。
12)、Oracle从下到上处理Where子句中多个查询条件，以是表连接语句应写在其他Where条件前，可以过滤掉最大数量记录的条件必须写在Where子句的末端。
13)、Oracle从右到左处理From子句中的表名，以是在From子句中包含多个表的情形下，将记录最少的表放在末了。
14)、Order By语句中的非索引列会降落性能，可以通过添加索引的办法处理。严格掌握在Order By语句中利用表达式。
15)、不同区域涌现的相同的Sql语句，要担保查询字符完备相同，以利用SGA共享池，防止相同的Sql语句被多次剖析。
16)、多利用内部函数提高Sql效率。
17)、当在Sql语句中连接多个表时，利用表的别名，并将之作为每列的前缀。这样可以减少解析韶光。
18)、根据SQL不同设定优化模式的办法，选择不同的优化策略，通过SELECT /+ALL+_ROWS/ ……;来设定。可用的HINT包括/+ALL_ROWS/、/+FIRST_ROWS/、/+CHOOSE/、/+RULE/ 等一样平常在SQL前加first_rows策略，速率都会提高，分外情形下改用choose策略。（本策略架构包已经支持）
19)、对付大表查询中的列应只管即便避免进行诸如Ｔｏ＿ｃｈａｒ，ｔｏ＿ｄａｔｅ，ｔｏ＿ｎｕｍｂｅｒ等转换
20)、有索引的只管即便用索引，有用到索引的条件写在前面
21)、如有可能和有必要就建立一些索引
22)、只管即便避免进行全表扫描，限定条件尽可能多，以便更快搜索到要查询的数据
21.要求转发和重定向的差异?
forword -- 要求转发 :
1、做事器端跳转，地址栏不改变
2、实行到跳转语句后立时无条件跳转，之后的代码不再实行(跳转之前一定要开释全部资源)
3、request设置的属性在跳转后的页面仍可以利用
4、利用<jsp:param name=\"大众参数名\"大众 value=\"大众参数值\公众 />通报参数
redirct-- 重定向:
1、客户端跳转,地址栏改变
2、所有代码实行完毕后跳转
3、跳转后的页面不能利用上一个页面的request属性
4、利用地址重写通报参数（response.sendRedirect(\"大众URL?参数名＝参数值\"大众)）
22.String，StringBuffer、StringBuilder的差异？
答: String是一个分外的引用数据类型，是一个长度不可变的字符序列，没有缓冲区，一旦创建就不会发生变革了。纵然重新赋值不是在原来工具的根本上改变的，而是创建了一个新的工具，将引用指向这个新的工具，摧残浪费蹂躏空间，效率比较低。
StringBuffer、StringBuilder是容器，是可变的字符串序列，存放于堆内存。
StringBuffer是JDK1.0版本的，线程是安全的，效率比较低。StringBuilder是JDK1.5涌现的，线程不屈安，效率高。
23.Hashtable和HashMap的差异?
Hashtable的底层数据构造是哈希表，不可以存储null键和null值，线程同步，效率低。JDK1.0.
HashMap的底层数据构造是哈希表，可以存储null键和null值，线程不同步，将Hashtable替代，JDK1.2效率高。担保键的唯一性的 依据是hashCode和equals方法。
24.事务便是访问可能更新数据库各种数据项的一个可实行单元
25.Struts2中访问多个Action怎么办?
通过配置method属性,通配符,或者动态访问
26.struts中不存在线程安全问题,由于它是一个实例,数据封装有模型驱动,方法封装,属性驱动,Ognl表达式
27. zookeeper端口号为:2181 SVN端口号:3690
Mysql端口号:3306 oracle端口号:1521 ActiveMQ:61616 Redis端号口:6379
28. Webservice好处:
相称于一个借口,实现跨平台跨源交互,底层是SOAP协议.是基于做事器与做事器之间的.有三种掩护规范
是阿帕奇下的cxf框架实现的
29.什么时候进行序列化?
序列化是一种用来处理工具流的机制
，所谓工具流便是将工具的内容进行流化。可以对流化后的工具进行读写操作，也可将流化后的工具传输于网络之间。序列化是为理解决在对工具流进行读写操作时所引发的问题。
序列化的实现：将须要被序列化的类实现Serializable接口，该接口没有须要实现的方法，implements Serializable只是为了标注该工具是可被序列化的，然后利用一个输出流(如：FileOutputStream)来布局一个ObjectOutputStream(工具流)工具，接着，利用ObjectOutputStream工具的writeObject(Object obj)方法就可以将参数为obj的工具写出(即保存其状态)，要规复的话则用输入流;
什么时候利用序列化：
一：工具序列化可以实现分布式工具。紧张运用例如：RMI要利用工具序列化运行远程主机上的做事，就像在本地机上运行工具时一样。
二：java工具序列化不仅保留一个工具的数据，而且递归保存工具引用的每个工具的数据。可以将全体工具层次写入字节流中，可以保存在文件中或在网络连接上通报。利用工具序列化可以进行工具的\公众深复制\公众，即复制工具本身及引用的工具本身。序列化一个工具可能得到全体工具序列。
30.浅谈Shiro框架
1.Spring security 与apache shiro 差别：
shiro配置更加随意马虎理解，随意马虎上手；security配置相比拟较难懂。
在spring的环境下，security整合性更好。Shiro对很多其他的框架兼容性更好，号称是无缝集成。
shiro 不仅仅可以利用在web中，它可以事情在任何运用环境中。
在集群会话时Shiro最主要的一个好处或许便是它的会话是独立于容器的。
Shiro供应的密码加密利用起来非常方便。
2.掌握精度：
Shiro也支持表明办法。
表明办法掌握权限只能是在方法上掌握，无法掌握类级别访问。
过滤器办法掌握是根据访问的URL进行掌握。许可利用匹配URL，以是可以进行粗粒度，也可以进行细粒度掌握。
URL权限过滤
shiro安全框架：
+ehcache缓存
1)、引入依赖pom.xml
<!-- Apache Shiro 权限架构 -->
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-all</artifactId>
<version>1.2.3</version>
</dependency>
2)、核心filter，一个filter相称于10个filter；web.xml
把稳：shiro的filter必须在struts2的filter之前，否则action无法创建
<!-- Shiro Security filter filter-name这个名字的值将来还会在spring中用到 -->
<filter>
<filter-name>shiroFilter</filter-name>
<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
<init-param>
<param-name>targetFilterLifecycle</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>shiroFilter</filter-name>
<url-pattern>/</url-pattern>
</filter-mapping>
3)、在spring applicationContext.xml中记载shiro配置文件,放在事务管理器之前配置
<aop:aspectj-autoproxy proxy-target-class=\"大众true\"大众 />
同时添加专门配置shiro的配置文件
<import resource=\公众spring/applicationContext-shiro.xml\"大众/>
和ehcache支持ehcache-shiro.xml
<ehcache updateCheck=\公众false\"大众 name=\"大众shiroCache\公众>
<defaultCache
maxElementsInMemory=\"大众10000\"大众
eternal=\"大众false\公众
timeToIdleSeconds=\"大众120\"大众
timeToLiveSeconds=\"大众120\公众
overflowToDisk=\"大众false\公众
diskPersistent=\公众false\"大众
diskExpiryThreadIntervalSeconds=\"大众120\公众
/>
</ehcache>
4)、applicationContext-shiro.xml，配置校验的策略，哪些校验，哪些放行
<?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:context=\"大众http://www.springframework.org/schema/context\"大众
xmlns:tx=\公众http://www.springframework.org/schema/tx\公众
xmlns:aop=\"大众http://www.springframework.org/schema/aop\"大众
xsi:schemaLocation=\"大众http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd\公众>
<description>Shiro的配置</description>
<!-- SecurityManager配置 -->
<!-- 配置Realm域 -->
<!-- 密码比较器 -->
<!-- 代理如何天生？ 用工厂来天生Shiro的干系过滤器-->
<!-- 配置缓存：ehcache缓存 -->
<!-- 安全管理 -->
<bean id=\"大众securityManager\"大众 class=\公众org.apache.shiro.web.mgt.DefaultWebSecurityManager\"大众>
<!-- Single realm app. If you have multiple realms, use the 'realms' property instead. -->
<property name=\"大众realm\"大众 ref=\"大众authRealm\公众/><!-- 引用自定义的realm -->
<!-- 缓存 -->
<property name=\公众cacheManager\"大众 ref=\公众shiroEhcacheManager\"大众/>
</bean>
<!-- 自定义权限认证 -->
<bean id=\公众authRealm\"大众 class=\"大众cn.itcast.jk.shiro.AuthRealm\公众>
<property name=\公众userService\"大众 ref=\"大众userService\"大众/>
<!-- 自定义密码加密算法 -->
<property name=\"大众credentialsMatcher\"大众 ref=\"大众passwordMatcher\"大众/>
</bean>
<!-- 设置密码加密策略 md5hash -->
<bean id=\"大众passwordMatcher\"大众 class=\公众cn.itcast.jk.shiro.CustomCredentialsMatcher\公众/>
<!-- filter-name这个名字的值来自于web.xml中filter的名字 -->
<bean id=\公众shiroFilter\公众 class=\公众org.apache.shiro.spring.web.ShiroFilterFactoryBean\公众>
<property name=\"大众securityManager\公众 ref=\"大众securityManager\公众/>
<!--登录页面 -->
<property name=\公众loginUrl\"大众 value=\"大众/index.jsp\"大众></property>
<!-- 登录成功后 -->
<property name=\"大众successUrl\公众 value=\"大众/home.action\"大众></property>
<property name=\"大众filterChainDefinitions\公众>
<!-- /代表下面的多级目录也过滤 -->
<value>
/index.jsp = anon
/home = anon
/sysadmin/login/login.jsp = anon
/sysadmin/login/logout.jsp = anon
/login = anon
/logout = anon
/components/ = anon
/css/ = anon
/images/ = anon
/js/ = anon
/make/ = anon
/skin/ = anon
/stat/ = anon
/ufiles/ = anon
/validator/ = anon
/resource/ = anon
/ = authc
/. = authc
</value>
</property>
</bean>
<!-- 用户授权/认证信息Cache, 采取EhCache 缓存 -->
<bean id=\"大众shiroEhcacheManager\"大众 class=\"大众org.apache.shiro.cache.ehcache.EhCacheManager\"大众>
<property name=\"大众cacheManagerConfigFile\公众 value=\"大众classpath:ehcache-shiro.xml\"大众/>
</bean>
<!-- 担保实现了Shiro内部lifecycle函数的bean实行 -->
<bean id=\"大众lifecycleBeanPostProcessor\"大众 class=\"大众org.apache.shiro.spring.LifecycleBeanPostProcessor\"大众/>
<!-- 天生代理，通过代理进行掌握 -->
<bean class=\"大众org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator\"大众
depends-on=\"大众lifecycleBeanPostProcessor\"大众>
<property name=\公众proxyTargetClass\"大众 value=\"大众true\"大众/>
</bean>
<!-- 安全管理器 -->
<bean class=\公众org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor\公众>
<property name=\"大众securityManager\公众 ref=\"大众securityManager\公众/>
</bean>
</beans>
5)、自定义realm AuthRealm
在认证、授权内部实现机制中都有提到，终极处理都将交给Realm进行处理。
由于在Shiro中，终极是通过Realm来获取运用程序中的用户、角色及权限信息的。
常日情形下，在Realm中会直接从我们的数据源中获取Shiro须要的验证信息。可以说，Realm是专用于安全框架的DAO.
public class AuthRealm extends AuthorizingRealm{
private UserService userService;
public void setUserService(UserService userService) {
this.userService = userService;
}
//授权
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
System.out.println(\"大众授权\公众);
//获取当前用户
User user = (User)principals.fromRealm(getName()).iterator().next();
//得到权限字符串
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
Set<Role> roles = user.getRoles();
List<String> list = new ArrayList();
for(Role role :roles){
Set<Module> modules = role.getModules();
for(Module m:modules){
if(m.getCtype()==0){
//解释是主菜单
list.add(m.getCpermission());
}
}
}
info.addStringPermissions(list);
return info;
}
//认证 登录
protected AuthenticationInfo doGetAuthenticationInfo(
AuthenticationToken token) throws AuthenticationException {
System.out.println(\公众认证\"大众);
UsernamePasswordToken upToken = (UsernamePasswordToken)token;
User user = userService.findUserByName(upToken.getUsername());
if(user==null){
return null;
}else{
AuthenticationInfo info = new SimpleAuthenticationInfo(user, user.getPassword(), getName());
return info;
}
}
}
6)、修正传统登录为shiro登录
package cn.itcast.jk.action;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.apache.shiro.subject.Subject;
import cn.itcast.common.SysConstant;
import cn.itcast.jk.service.UserService;
/
@Description: 登录和推出类
@Author: 靳磊
@Company: http://java.itcast.cn
@CreateDate: 2014年10月31日
/
public class LoginAction extends BaseAction {
private static final long serialVersionUID = 1L;
private String username;
private String password;
private UserService userService;
public void setUserService(UserService userService) {
this.userService = userService;
}
public String login() throws Exception {
/
shiro登录办法：根据用户名获取密码，密码为null造孽用户；有密码检讨是否用户填写的密码
登录成功后无需往httpsession中存放当前用户，这样就跟web容器绑定，关联太紧密；它自己创建
subject工具，实现自己的session。这个跟web容器分开，实现松耦合。
/
//调用shiro判断当前用户是否是系统用户
Subject subject = SecurityUtils.getSubject(); //得到当前用户
//shiro是将用户录入的登录名和密码（未加密）封装到token工具中
UsernamePasswordToken token = new UsernamePasswordToken(userName,password);
try{
subject.login(token); //自动调用AuthRealm.doGetAuthenticationInfo
//写seesion，保存当前user工具
User curUser = (User)subject.getPrincipal(); //从shiro中获取当前用户
System.out.println(curUser.getDept().getDeptName()); //让
Set<Role> roles = curUser.getRoles();
for(Role role :roles){
Set<Module> moduless = role.getModules();
for(Module m :moduless)
System.out.println(m.getName());
}
session.put(SysConstant.CURRENT_USER_INFO, curUser); //Principal 当前用户工具
}catch(Exception ex){
super.put(\"大众errorInfo\公众,\"大众用户名密码缺点，请重新填写!\公众);
ex.printStackTrace();
return \"大众login\公众;
}
return SUCCESS;
}
public String logout(){
session.remove(SysConstant.CURRENT_USER_INFO); //删除session
return \"大众logout\"大众;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
7)、授权(另一种加载数据的思想 可省略由于在登录时已加载)
根据用户查询出角色对应的权限，并返回权限串
-hql，service
public List<String> getPermission(String userName) {
List<String> _list = new ArrayList<String>();
//用户，角色，权限，两级多对多，利用left join关联实现
String hql = \"大众select p from User as u left join u.roles as r left join r.modules as p where u.username='\公众+userName+\"大众'\"大众;
List<Module> moduleList = baseDao.find(hql, Module.class, null);
for(Module m : moduleList){
if(m!=null){ //不雅观察hibernate实现的SQL，会多出一条Null记录
_list.add(m.getName());
}
}
return _list;
}
在realm中进行授权userService.getPermission
//授权
protected AuthorizationInfo doGetAuthorizationInfo(
PrincipalCollection principals) {
log.info(\"大众实行授权...\"大众);
//获取登任命户的权限，合营jsp页面中的shiro标签进行掌握
User curUser = (User) principals.fromRealm(getName()).iterator().next();
String userName = curUser.getUsername();
List<String> sList = userService.getPermission(userName );
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
for(String permission : sList){
//设置当前用户的权限
authorizationInfo.addStringPermission(permission);
}
return authorizationInfo;
}
8)、页面利用shiro标签，/home/title.jsp 主菜单
<%@ taglib uri=\"大众http://shiro.apache.org/tags\"大众 prefix=\公众shiro\公众%>
<shiro:hasPermission name=\"大众sysadmin\公众>
<span id=\公众topmenu\公众 onclick=\公众toModule('sysadmin');\公众>系统管理</span>
</shiro:hasPermission>
