Java 面试注意题 java面试注意什么

1. .A表中有a，b，c三个字段，B表中有a，b，c三个字段，把A表数据复制到B表

.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>