Autowired热门博客列表 -
ITeye博客频道 -
博客专栏推荐
本月博客排行
年度博客排行
最新文章列表
service层会自动注入（autowired）dao层的interface，如何正常测试service层的逻辑，而不真正的触动dao层的代码，即不往数据库做实际操作，变成了一个需要解决的问题。首先，看一下我们service层的代码：
[java] view plain copy
最近研究shiro，一开头就遇到了大困难，调试了3小时。问题描述如下：shiro和spring mvc整合，shiro自定义了realm。其中自定义的realm里面居然不能使用@Autowi ...
使用 @Autowired 注解进行装配，只能是根据类型进行匹配。@Autowired 注解可以用于 Setter 方法、构造函数、字段，甚至普通方法，前提是方法必须有至少一个参数。@Autowired 可以用于数组和使用泛型的集合类型。然后 Spring 会将容器中所有类型符合的 Bean 注入进来。@Autowired 标注作用于 Map 类型时，如果 Map 的 key 为 String 类型 ...
在使用shiro时，打算启用shiro的注解功能如下:
@RequestMapping(method = RequestMethod.GET,value = &/menuManager&)
@RequiresPermissions(&sys:menu:*&)
public String
menusManager(Model model){
ServletContext,是一个全局的储存信息的空间，服务器开始建立，服务器关闭销毁。request，每次请求一个；session，一个会话一个；而servletContext，所有用户共用一个。
ServletContext维护着一个服务器中的一个特定URL名字空间（比如，/myapplication）下的所有Servlet，Filter，JSP，JavaBe ...
之前写的程序，运行正常，后来拿出来复习的时候，发现service和dao使用@Resource无法正常注入，而用@Autowired就可以正常注入，显示log日志，所有对象均能够正常实例化，就是没有inject的过程。后来终于发现原因，tomcat5.5不支持@Resource。。@Autowired是的可以正常注入，而@Resource是JavaEE包下面的，不支持tomca ...
在平时休闲时间做一个学习型项目练手，在练习过程中，遇到一个spring拦截器不生效的问题，拦截器代码如下：
// 该注解标示该类为切面类
@Component
public class LogAopAction {
@Autowired
private LogDao logD
@Around(&execution(* com.la ...
参考链接
Spring 注解 javax.annotation.Resource和@Autowired
共同点：两者都可以写在字段和setter方法上。两者如果都写在字段上，就不需要写写setter方法。
http://blog.csdn.net/xiaoyiyz/article/details/
/articles/ruaMBn
要想使用Annotation必须在XML配置文件头中，加入如下代码：
&?xml version=&1.0& encoding=&UTF-8&?&
&!-- spring配置文件固定写法 --&
&beans xmlns=&http://www.springframework.org/schema/beans& ...
项目开发告一段落，就静下心来看看前人写的代码，遇不懂或疑惑之处，便翻阅字典，
看罢，哦…………原来是这样，不禁叹声，于是作为札记以记录，以便日后所用。
心得：看会了不是你的，理解了、用过了才是你的。
Spring注解@Component、@Repository、@Service、@Controller区别
总结：component通用，其他3个精细用，分别对应MVC中的mc,配置让 ...
http://blog.arganzheng.me/posts/quartz-and-spring-integration-ioc-autowire.html
Quartz与Spring的整合-Quartz中的job如何自动注入spring容器托管的对象
December 29, 2012
Quartz中的job是由Quartz框架动态创建的（配置该job的cla ...
项目中碰到了Junit和Spring整合的问题，对于通过注解方式注入的bean，稍微有点麻烦，总结如下：
1. 在项目pom.xml中添加对spring-test包的依赖，非maven工程可直接通过build path添加该包
&dependency&
&groupId&org.springframework&/grou ...
public void init(ServletConfig config) throws ServletException {
super.init(config);
SpringBeanAutowiringSupport.processInjectionBasedOnServletContext(this, config.getServletContext());
今天在研究了下spring的@Autowired的注入方式
@Autowired 默认是按照byType进行注入的，但是当byType方式找到了多个符合的bean，又是怎么处理的？
经过一些代码的测试，我发现，Autowired默认先按byType，如果发现找到多个bean，则，又按照byName方式比对，如果还有多个，则报出异常。
@Autowired
　在使用Spring框架中@Autowired标签时默认情况下使用 @Autowired注释进行自动注入时，Spring 容器中匹配的候选 Bean 数目必须有且仅有一个。当找不到一个匹配的 Bean 时，Spring 容器将抛出 BeanCreationException 异常，并指出必须至少拥有一个匹配的 Bean。
　　Spring 允许我们通过 @Qualifier注释指定注入 Bean 的 ...
@Resource注解
@Resource注解和@Autowired一样，也可以标注在字段或属性的setter方法上
@Resource默认按名称装配，名称可以通过name属性指定。当找不到与名称匹配的bean时，才会按类型装配
若注解标注在字段上且未指定name属性，则默认取字段名作为bean名称寻找依赖对象
若注解标注在setter上且未指定name属性，则默认取属性名作为bean名称寻 ...
Spring提供了对配置中创建对象的字段实例注入。但如果是通过代码创建或者动态创建的对象，由于不受Spring管理，因此没有机会执行字段实例的注入。Google了一把，没发现可以用的方法。因此只能写了一小段代码。对于这种情况，可以通过反射的方式找到对象的字段和方法定义，并注入之。以下为具体实现。Registry类保存了Spring生成的context，在需要的时候随时可以调用。
public f ...
以前很少用Spring@Autowired注解与自动装配，
今天搜索了一下相关的内容，发现有提到这样的问题。
注解引发的问题：
1、缺乏明确的配置导致程序的依赖注入关系不明确。
2、不利于模块化的装配。
3、给维护带来麻烦，因为你要根据源代码找到依赖关系。
4、通用性不好。如果你哪天抛开了Spring，换了别的Ioc容器，那么你的注解要一个个的删除。
@Autowired注解与自动装配 跟xml的b ...
一、基本概念
依赖注入： 在运行期，由外部容器动态的将依赖的对象注入到组件中（实例化所有的bean，然后按需注入到组件。）
控制反转：依赖对象的创建和管理（控制权）转移给了外部容器，这样可以很方便的通过容器的配置来管理对象。
容器：可以简单的想象为一个存放了一些单例的实例化对象（bean）的容器，你可以通过容器接口从容器里面拿你需要的对象实例。
二、Spring的主要特性
1. 降低组件之间的耦合度 ...
这是前段时间遇到的一个问题，确定是因为泛型编译导致的，但是特别详细的原因还没有深入研究过，遇到的同志可以看下哈。
@Controller
public class UserController {
@Autowired
UserManager userM
上面的controller中自动注入了一个UserManager，该manager是一个泛型类。
& 上一页 1
相关知识库
38671关注/3162收录
3836关注/393收录
17744关注/212收录
37236关注/3748收录
博客人气排行榜
博客电子书下载排行博客分类：
公司一直不是ssh零配置的框架，每次写action都要在applicationcontext和struts里面配置，好麻烦，最近有空，写了一个ssh零配置的框架
这里写了一个小的项目，以用户权限管理为例
先做准备工作：
1.struts2去官网下载最新版struts开发包
2.hibernate4去官网下载最新版hibernate4开发包
3.spring3去官网下载最新版spring3开发包
一、先建立一个空的web的项目sshFrame，加载必须的包
1.添加struts2必备的包。我下载的是最近的struts2.3.8
asm-3.3.jar
--ASM字节码库 ，使用“cglib”则必要
aopalliance-1.0.jar
--这个包为AOP提供了最普通和通用的接口
commons-fileupload-1.2.2.jar
--Struts2上传下载的jar
commons-io-2.0.1.jar
--Struts2上传下载的jar
commons-logging-1.1.1.jar
--Jakarta的通用日志记录包
freemarker-2.3.19.jar
ognl-3.0.6.jar
--支持ognl表达式
struts2-core-2.3.8.jar
--struts2的核心包
struts2-spring-plugin-2.3.8.jar
--struts2与spring整合所需
struts2-convention-plugin-2.3.8.jar
--struts2零配置注释用
xwork-core-2.3.8.jar
可以不加 struts2-config-browser-plugin-2.3.1.1.jar为struts协助开发需要的包：可以输入查看系统所有已经存在的action,配置不正确就可以在这里看出来;
2.添加Hibernate 所需要的包。hibernate-4.1.9.Final
把下载下来的hibernate\lib\required下的包全部拷贝进去，分别是
antlr-2.7.7.jar
--语言转换工具，hibernate用他将hql语句转换为sql语句
dom4j-1.6.1.jar
--解析xml文档的工具
hibernate-commons-annotations-4.0.1.Final.jar
hibernate-core-4.1.9.Final.jar
hibernate-jpa-2.0-api-1.0.1.Final.jar
javassist-3.17.1-GA.jar
jboss-logging-3.1.0.GA.jar
jboss-transaction-api_1.1_spec-1.0.0.Final.jar
还有加入hibernate\lib\optional\c3p0\c3p0-0.9.1.jar
hibernate-ehcache-4.1.9.Final.jar
ehcache-core-2.4.3.jar
slf4j-api-1.6.4.jar
slf4j-log4j12-1.6.4.jar
3添加spring3 所需要的包 spring-framework-3.2.0.RELEASE
spring-aop-3.2.0.RELEASE.jar
spring-aspects-3.2.0.RELEASE.jar
spring-beans-3.2.0.RELEASE.jar
spring-context-3.2.0.RELEASE.jar
spring-core-3.2.0.RELEASE.jar
spring-expression-3.2.0.RELEASE.jar
spring-instrument-3.2.0.RELEASE.jar
spring-jdbc-3.2.0.RELEASE.jar
spring-jms-3.2.0.RELEASE.jar
spring-orm-3.2.0.RELEASE.jar
spring-oxm-3.2.0.RELEASE.jar
spring-test-3.2.0.RELEASE.jar --测试时用
spring-tx-3.2.0.RELEASE.jar
--事务处理所用
spring-web-3.2.0.RELEASE.jar
aspectjweaver-1.5.3.jar
--spring所依赖的包
asm-commons-3.3.jar
Commons—pool.jar ,commons-dbcp.jar
----------DBCP数据库连接池，Apache的jakarta组织开发 的，tomcat连接池也是dbcp（可选）
cglib.jar----------------------------高效的代码生成工具, Hibernate用它在运行时扩展 Java类和实现 Java 接
--标准的JTA API(JTA即java事物API，JTA事务比JDBC事务更强大。一个JTA事务可以有多个参与者，而一个JDBC事务则被限定在一个单一的数据库连接)，我暂时还没加，先备着
mysql-connector-java-5.1.18-bin.jar
log4j-1.2.16.jar
二、添加配置文件
在struts包下struts\src\apps\blank\src\main\resources提供了空白的struts.xml文件，把它复制到项目的src下
&!-- spring 配置 --&
&listener&
&listener-class&org.springframework.web.context.ContextLoaderListener&/listener-class&
&/listener&
&context-param&
&description&Spring上下文&/description&
&param-name&contextConfigLocation&/param-name&
&param-value&classpath:applicationContext*.xml&/param-value&
&/context-param&
&!-- hibernate 懒加载的问题过滤 ,可以不配置 --&
&description&hibernate Session 过滤器&/description&
&filter-name&openSessionInViewFilter&/filter-name&
&filter-class&org.springframework.orm.hibernate4.support.OpenSessionInViewFilter&/filter-class&
&filter-mapping&
&filter-name&openSessionInViewFilter&/filter-name&
&url-pattern&/*&/url-pattern&
&/filter-mapping&
&!-- struts配置 --&
&filter-name&struts2&/filter-name&
&filter-class&org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter&/filter-class&
&filter-mapping&
&filter-name&struts2&/filter-name&
&url-pattern&/*&/url-pattern&
&/filter-mapping&
struts.xml配置
&!-- 使用Spring --&
&constant name="struts.objectFactory" value="spring" /&
&constant name="struts.devMode" value="true" /&
&constant name="struts.configuration.xml.reload" value="true" /&
&package name="default" extends="struts-default" namespace="/"&
&interceptors&
&!-- 使用权限拦截 --&
&interceptor name="authority" class="com.sshFrame.zero.interceptor.AuthorityInterceptor"/&
&!-- 异常拦截 --&
&interceptor name="exceptionInterceptor" class="com.sshFrame.zero.interceptor.ExceptionInterceptor"/&
&!-- 解决struts安全漏洞，拦截所有的带有#号的url --&
&interceptor-stack name="baseStack"&
&interceptor-ref name="authority"/&
&interceptor-ref name="exceptionInterceptor"/&
&interceptor-ref name="params"&
&param name="excludeParams"&.*\\u0023.*&/param&
&/interceptor-ref&
&interceptor-ref name="defaultStack"/&
&/interceptor-stack&
&/interceptors&
&!-- 配置默认拦截器栈 --&
&default-interceptor-ref name="baseStack"/&
&global-results&
&result name="login"&/index.jsp&/result&
&result name="error"&/error.jsp&/result&
&/global-results&
&/package&
applicationcontext.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:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:dwr="http://www.directwebremoting.org/schema/spring-dwr"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.2.xsd"&
&bean id="dataSource" class="mons.dbcp.BasicDataSource"&
&property name="driverClassName" value="com.mysql.jdbc.Driver"&&/property&
&property name="url" value="jdbc:mysql://127.0.0.1:3306/osdesignaid"&&/property&
&property name="username" value="root"&&/property&
&property name="password" value="root"&&/property&
&bean id="sessionFactory"
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"&
&property name="dataSource" ref="dataSource" /&
&property name="hibernateProperties"&
&prop key="hibernate.dialect"&org.hibernate.dialect.MySQLDialect&/prop&
&prop key="hibernate.current_session_context_class"&thread&/prop&
&prop key="hibernate.cache.region.factory_class"&org.hibernate.cache.EhCacheRegionFactory&/prop&
&prop key="hibernate.show_sql"&true&/prop&
&prop key="hibernate.format_sql"&true&/prop&
&prop key="hibernate.hbm2ddl.auto"&update&/prop&
&/property&
&property name="packagesToScan"&
&value&com.sshFrame.zero.pojo&/value&
&value&com.sshFrame.test.pojo&/value&
&/property&
&aop:aspectj-autoproxy /&&!-- 代理 --&
&!-- 定义事务管理器 --&
&bean id="txManager"
class="org.springframework.orm.hibernate4.HibernateTransactionManager"&
&property name="sessionFactory" ref="sessionFactory" /&
&!-- 申明annotation 加载事务驱动 --&
&tx:annotation-driven transaction-manager="txManager" proxy-target-class="true"/&
&tx:advice id="txAdvice" transaction-manager="txManager"&
&tx:attributes&
&tx:method name="save*" propagation="REQUIRED" /&
&tx:method name="add*" propagation="REQUIRED" /&
&tx:method name="create*" propagation="REQUIRED" /&
&tx:method name="insert*" propagation="REQUIRED" /&
&tx:method name="update*" propagation="REQUIRED" /&
&tx:method name="merge*" propagation="REQUIRED" /&
&tx:method name="del*" propagation="REQUIRED" /&
&tx:method name="remove*" propagation="REQUIRED" /&
&tx:method name="put*" propagation="REQUIRED" /&
&tx:method name="use*" propagation="REQUIRED"/&
&!--hibernate4必须配置为开启事务 否则 getCurrentSession()获取不到--&
&tx:method name="get*" propagation="REQUIRED" read-only="true" /&
&tx:method name="count*" propagation="REQUIRED" read-only="true" /&
&tx:method name="find*" propagation="REQUIRED" read-only="true" /&
&tx:method name="list*" propagation="REQUIRED" read-only="true" /&
&tx:method name="*" read-only="true" /&
&/tx:attributes&
&/tx:advice&
&aop:config expose-proxy="true"&
&!-- 只对业务逻辑层实施事务 --&
&aop:pointcut id="txPointcut" expression="execution(* cn.javass..service..*.*(..))" /&
&aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/&
&/aop:config&
&!-- 自动扫描包 --&
&context:annotation-config /&
&context:component-scan base-package="com.sshFrame.zero.*,com.sshFrame.test.*" annotation-config="true"/&
配置都写好了，
改写基本的框架类了
package com.sshFrame.zero.
import java.io.S
import java.lang.reflect.F
import java.lang.reflect.ParameterizedT
import java.lang.reflect.T
import java.util.L
import javax.persistence.Id;
import org.hibernate.C
import org.hibernate.HibernateE
import org.hibernate.Q
import org.hibernate.S
import org.hibernate.SessionF
import org.hibernate.criterion.E
import org.springframework.beans.factory.annotation.A
* 基于hibernate的BaseDao
* Spring3对Hibernate4已经没有了HibernateDaoSupport和HibernateTemplate的支持，使用了原生态的API
* @author 雪精灵
* @param &T&
public class BaseDao&T extends Serializable& {
@Autowired
private SessionFactory sessionF
//当前泛型类
@SuppressWarnings("rawtypes")
private Class entityC
//当前主键名称
private final String HQL_LIST_ALL;
private final String HQL_COUNT_ALL;
@SuppressWarnings("rawtypes")
public Class getEntityClass() {
return entityC
@SuppressWarnings("rawtypes")
public void setEntityClass(Class entityClass) {
this.entityClass = entityC
@SuppressWarnings("rawtypes")
public BaseDao() {
//获取当前泛型类
Type type = this.getClass().getGenericSuperclass();
if (type.toString().indexOf("BaseDao") != -1) {
ParameterizedType type1 = (ParameterizedType)
Type[] types = type1.getActualTypeArguments();
setEntityClass((Class) types[0]);
type = ((Class)type).getGenericSuperclass();
ParameterizedType type1 = (ParameterizedType)
Type[] types = type1.getActualTypeArguments();
setEntityClass((Class) types[0]);
getPkname();
HQL_LIST_ALL="from "+this.entityClass.getSimpleName()+" order by "+pkname+" desc";
HQL_COUNT_ALL="select count(*) from "+this.entityClass.getSimpleName();
* 获取主键名称
public String getPkname() {
Field[] fields = this.entityClass.getDeclaredFields();//反射类字段
for (Field field : fields) {
field.isAnnotationPresent(Id.class);
this.pkname=field.getName();
* 保存实例
* @param t
* @throws HibernateException
public void save(T t) throws HibernateException{
Session session=
session=sessionFactory.openSession();
session.beginTransaction();
session.save(t);
session.getTransaction().commit();
} catch (HibernateException e) {
e.printStackTrace();
throw new HibernateException(e);
session.close();
* 修改实例
* @param t
* @throws HibernateException
public void update(T t) throws HibernateException{
Session session=
session=sessionFactory.openSession();
session.beginTransaction();
session.update(t);
session.getTransaction().commit();
} catch (HibernateException e) {
e.printStackTrace();
throw new HibernateException(e);
session.close();
* 删除实例
* @param t
* @throws HibernateException
public void delete(T t) throws HibernateException{
Session session=
session=sessionFactory.openSession();
session.beginTransaction();
session.delete(t);
session.getTransaction().commit();
} catch (HibernateException e) {
e.printStackTrace();
throw new HibernateException(e);
session.close();
* 获取实例
* @param id
* @throws HibernateException
@SuppressWarnings("unchecked")
public T get(Serializable id) throws Exception{
Session session=
session=sessionFactory.openSession();
session.beginTransaction();
t=(T) session.get(getEntityClass(), id);
session.getTransaction().commit();
} catch (HibernateException e) {
e.printStackTrace();
throw new HibernateException(e);
session.close();
* 查询全部
* @throws HibernateException
@SuppressWarnings("unchecked")
public List&T& findAll() throws Exception {
List&T& list=
Session session=
session = sessionFactory.openSession();
session.beginTransaction();
Query query = session.createQuery(HQL_LIST_ALL);
list = query.list();
session.getTransaction().commit();
} catch (HibernateException e) {
e.printStackTrace();
session.close();
* 查询总数
* @throws HibernateException
public Integer findAllCount() throws Exception {
Session session=
Integer count=0;
session = sessionFactory.openSession();
session.beginTransaction();
Query query = session.createQuery(HQL_COUNT_ALL);
List&?& list = query.list();
session.getTransaction().commit();
if(list!=null&&!list.isEmpty()){
count=((Integer) list.get(0)).intValue();
} catch (HibernateException e) {
e.printStackTrace();
session.close();
* @param criteria
* @throws HibernateException
@SuppressWarnings("unchecked")
public List&T& findByCriteria(Criteria criteria) throws Exception {
List&T& list=
Session session=
session = sessionFactory.openSession();
session.beginTransaction();
Criteria criteria1 = session.createCriteria(getEntityClass());
criteria1=
list = criteria1.list();
session.getTransaction().commit();
} catch (HibernateException e) {
e.printStackTrace();
session.close();
* @param t
* @throws HibernateException
@SuppressWarnings("unchecked")
public List&T& findByExample(T t) throws Exception {
List&T& list=
Session session=
Example example = Example.create(t);
session = sessionFactory.openSession();
session.beginTransaction();
Criteria criteria = session.createCriteria(getEntityClass());
criteria.add(example);
list = criteria.list();
session.getTransaction().commit();
} catch (HibernateException e) {
e.printStackTrace();
session.close();
* @param hql
* @param objects
* @throws HibernateException
@SuppressWarnings("unchecked")
public List&Object[]& findByHql(String hql,final Object...objects) throws Exception{
List&Object[]& list=
Session session=
session=sessionFactory.openSession();
session.beginTransaction();
Query query = session.createQuery(hql);
for (int i = 0; i & objects. i++) {
query.setParameter(i, objects[i]);
list = query.list();
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.close();
* @param hql
* @param objects
* @throws HibernateException
@SuppressWarnings("unchecked")
public List&Object[]& findBySql(String sql,final Object...objects){
List&Object[]& list=
Session session=
session=sessionFactory.openSession();
session.beginTransaction();
Query query = sessionFactory.getCurrentSession().createSQLQuery(sql);
for (int i = 0; i & objects. i++) {
query.setParameter(i, objects[i]);
list = query.list();
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.close();
BaseService
package com.sshFrame.zero.
import java.io.S
import java.util.L
import com.sshFrame.zero.dao.BaseD
* @author 雪精灵
public class BaseService&T extends Serializable& {
protected BaseDao&T& baseD
public void save(T t) throws Exception{
baseDao.save(t);
public void update(T t) throws Exception{
baseDao.update(t);
public void delete(T t) throws Exception{
baseDao.delete(t);
public T get(Serializable id) throws Exception{
return baseDao.get(id);
public List&T& findAll() throws Exception{
return baseDao.findAll();
public List&T& findByExample(T t) throws Exception{
return baseDao.findByExample(t);
public BaseDao&T& getBaseDao() {
return baseD
public void setBaseDao(BaseDao&T& baseDao) {
this.baseDao = baseD
先上7个pojo
package com.sshFrame.zero.
import java.io.S
import java.util.HashS
import java.util.S
import javax.persistence.CascadeT
import javax.persistence.C
import javax.persistence.E
import javax.persistence.FetchT
import javax.persistence.GeneratedV
import javax.persistence.Id;
import javax.persistence.OneToM
import javax.persistence.T
import org.hibernate.annotations.GenericG
@Table(name="userinfo")
public class Userinfo implements Serializable{
private static final long serialVersionUID = 1L;
private Set&Userrole& userroles=new HashSet&Userrole&();
@GenericGenerator(name = "generator", strategy = "uuid")
@GeneratedValue(generator = "generator")
@Column(name = "userid", unique = true, nullable = false, length = 50)
public String getUserid() {
public void setUserid(String userid) {
this.userid =
@Column(name = "username", nullable = false, length = 50)
public String getUsername() {
public void setUsername(String username) {
this.username =
@Column(name = "password", nullable = false, length = 50)
public String getPassword() {
public void setPassword(String password) {
this.password =
@Column(name = "depid", nullable = false, length = 50)
public String getDepid() {
public void setDepid(String depid) {
this.depid =
@Column(name = "dutyid", nullable = false, length = 50)
public String getDutyid() {
public void setDutyid(String dutyid) {
this.dutyid =
@OneToMany(cascade=CascadeType.REMOVE,mappedBy="userinfo",fetch=FetchType.LAZY)
public Set&Userrole& getUserroles() {
public void setUserroles(Set&Userrole& userroles) {
this.userroles =
package com.sshFrame.zero.
import java.io.S
import java.util.HashS
import java.util.S
import javax.persistence.CascadeT
import javax.persistence.C
import javax.persistence.E
import javax.persistence.FetchT
import javax.persistence.GeneratedV
import javax.persistence.Id;
import javax.persistence.OneToM
import javax.persistence.T
import org.hibernate.annotations.GenericG
@Table(name="role")
public class Role implements Serializable{
private static final long serialVersionUID = 1L;
private Set&Userrole& userroles=new HashSet&Userrole&();
private Set&Rolerights& rolerights=new HashSet&Rolerights&();
@GenericGenerator(name = "generator", strategy = "uuid")
@GeneratedValue(generator = "generator")
@Column(name = "id", unique = true, nullable = false, length = 50)
public String getId() {
public void setId(String id) {
@Column(name = "name", nullable = false, length = 50)
public String getName() {
public void setName(String name) {
this.name =
@OneToMany(cascade=CascadeType.REMOVE,fetch=FetchType.LAZY,mappedBy="role")
public Set&Userrole& getUserroles() {
public void setUserroles(Set&Userrole& userroles) {
this.userroles =
@OneToMany(cascade=CascadeType.REMOVE,fetch=FetchType.LAZY,mappedBy="role")
public Set&Rolerights& getRolerights() {
public void setRolerights(Set&Rolerights& rolerights) {
this.rolerights =
package com.sshFrame.zero.
import java.io.S
import java.util.HashS
import java.util.S
import javax.persistence.CascadeT
import javax.persistence.C
import javax.persistence.E
import javax.persistence.FetchT
import javax.persistence.GeneratedV
import javax.persistence.Id;
import javax.persistence.OneToM
import javax.persistence.T
import org.hibernate.annotations.GenericG
@Table(name="rights")
public class Rights implements Serializable{
private static final long serialVersionUID = 1L;
private Set&Rolerights& rolerights=new HashSet&Rolerights&();
@GenericGenerator(name = "generator", strategy = "uuid")
@GeneratedValue(generator = "generator")
@Column(name = "id", unique = true, nullable = false, length = 50)
public String getId() {
public void setId(String id) {
public String getName() {
@Column(name = "name", nullable = false, length = 50)
public void setName(String name) {
this.name =
@OneToMany(cascade=CascadeType.REMOVE,fetch=FetchType.LAZY,mappedBy="rights")
public Set&Rolerights& getRolerights() {
public void setRolerights(Set&Rolerights& rolerights) {
this.rolerights =
package com.sshFrame.zero.
import java.io.S
import java.util.HashS
import java.util.S
import javax.persistence.CascadeT
import javax.persistence.C
import javax.persistence.E
import javax.persistence.FetchT
import javax.persistence.GeneratedV
import javax.persistence.Id;
import javax.persistence.OneToM
import javax.persistence.T
import org.hibernate.annotations.GenericG
@Table(name="resources")
public class Resources implements Serializable{
private static final long serialVersionUID = 1L;
private Set&Rightsresources& rightsresourcs=new HashSet&Rightsresources&();
@GenericGenerator(name = "generator", strategy = "uuid")
@GeneratedValue(generator = "generator")
@Column(name = "id", unique = true, nullable = false, length = 50)
public String getId() {
public void setId(String id) {
@Column(name = "name", nullable = false, length = 50)
public String getName() {
public void setName(String name) {
this.name =
@Column(name = "url", nullable = false, length = 100)
public String getUrl() {
public void setUrl(String url) {
this.url =
@OneToMany(cascade=CascadeType.REMOVE,fetch=FetchType.LAZY,mappedBy="resources")
public Set&Rightsresources& getRightsresourcs() {
public void setRightsresourcs(Set&Rightsresources& rightsresourcs) {
this.rightsresourcs =
package com.sshFrame.zero.
import java.io.S
import javax.persistence.C
import javax.persistence.E
import javax.persistence.FetchT
import javax.persistence.GeneratedV
import javax.persistence.Id;
import javax.persistence.JoinC
import javax.persistence.ManyToO
import javax.persistence.T
import org.hibernate.annotations.GenericG
@Table(name="userrole")
public class Userrole implements Serializable{
private static final long serialVersionUID = 1L;
@GenericGenerator(name = "generator", strategy = "uuid")
@GeneratedValue(generator = "generator")
@Column(name = "id", unique = true, nullable = false, length = 50)
public String getId() {
public void setId(String id) {
@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name="userid")
public Userinfo getUserinfo() {
public void setUserinfo(Userinfo userinfo) {
this.userinfo =
@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name="roleid")
public Role getRole() {
public void setRole(Role role) {
this.role =
package com.sshFrame.zero.
import java.io.S
import javax.persistence.C
import javax.persistence.E
import javax.persistence.FetchT
import javax.persistence.GeneratedV
import javax.persistence.Id;
import javax.persistence.JoinC
import javax.persistence.ManyToO
import javax.persistence.T
import org.hibernate.annotations.GenericG
@Table(name="rolerights")
public class Rolerights implements Serializable{
private static final long serialVersionUID = 1L;
@GenericGenerator(name = "generator", strategy = "uuid")
@GeneratedValue(generator = "generator")
@Column(name = "id", unique = true, nullable = false, length = 50)
public String getId() {
public void setId(String id) {
@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name="roleid")
public Role getRole() {
public void setRole(Role role) {
this.role =
@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name="rightsid")
public Rights getRights() {
public void setRights(Rights rights) {
this.rights =
package com.sshFrame.zero.
import java.io.S
import javax.persistence.C
import javax.persistence.E
import javax.persistence.FetchT
import javax.persistence.GeneratedV
import javax.persistence.Id;
import javax.persistence.JoinC
import javax.persistence.ManyToO
import javax.persistence.T
import org.hibernate.annotations.GenericG
@Table(name="rightsresources")
public class Rightsresources implements Serializable{
private static final long serialVersionUID = 1L;
@GenericGenerator(name = "generator", strategy = "uuid")
@GeneratedValue(generator = "generator")
@Column(name = "id", unique = true, nullable = false, length = 50)
public String getId() {
public void setId(String id) {
@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name="rightsid")
public Rights getRights() {
public void setRights(Rights rights) {
this.rights =
@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name="resourcesid")
public Resources getResources() {
public void setResources(Resources resources) {
this.resources =
UserinfoService 这个一定要注意，要在setUserinfoDao方法里把当前的dao给basedao，否则，basedao会报空指针
package com.sshFrame.zero.service.
import java.util.L
import org.springframework.beans.factory.annotation.A
import org.
import org.springframework.stereotype.S
import com.sshFrame.zero.dao.users.UserinfoD
import com.sshFrame.zero.pojo.U
import com.sshFrame.zero.service.BaseS
* 用户管理
* @author 雪精灵
@Component("userinfoService")
public class UserinfoService extends BaseService&Userinfo&{
private UserinfoDao userinfoD
public UserinfoService() {
public Userinfo findlogin(String username,String password) throws Exception{
Userinfo userinfo=new Userinfo();
userinfo.setUsername(username);
userinfo.setPassword(password);
List&Userinfo& userinfos = findByExample(userinfo);
if(userinfos!=null&&!userinfos.isEmpty()){
userinfo=userinfos.get(0);
public List&?& used(String userid,String url) throws Exception {
String hql="select ur.userinfo.userid,re.name,re.url from Userrole ur,Role r,Rolerights rr,Rights ri,Rightsresources rs,Resources re "+
"where ur.role.id=r.id and r.id=rr.role.id and rr.rights.id=ri.id and ri.id=rs.rights.id and rs.resources.id=re.id and "+
"ur.userinfo.userid=? and re.url=?";
List&?& userResource = userinfoDao.findByHql(hql,userid,url);
return userR
public UserinfoDao getUserinfoDao() {
return userinfoD
* 一定要用set方法注入，并赋值给baseDao，否则baseDao为
* 只适用于注入一个Dao
* @param userinfoDao
@Autowired
public void setUserinfoDao(UserinfoDao userinfoDao) {
super.setBaseDao(userinfoDao);
this.userinfoDao = userinfoD
package com.sshFrame.zero.action.
import java.util.L
import javax.servlet.http.HttpServletR
import javax.servlet.http.HttpServletR
import org.apache.struts2.convention.annotation.A
import org.apache.struts2.convention.annotation.N
import org.apache.struts2.convention.annotation.R
import org.apache.struts2.interceptor.ServletRequestA
import org.apache.struts2.interceptor.ServletResponseA
import org.springframework.beans.factory.annotation.A
import org.springframework.context.annotation.S
import org.
import com.opensymphony.xwork2.ActionS
import com.sshFrame.zero.pojo.U
import com.sshFrame.zero.service.users.UserinfoS
* @author 雪精灵
@Namespace("/")
@Scope("prototype")
@Component("userinfoAction")
public class UserinfoAction extends ActionSupport implements ServletRequestAware,ServletResponseAware{
private static final long serialVersionUID = 1L;
private HttpServletR
private HttpServletR
@Autowired
private UserinfoService userinfoS
@Action(value="login",results={
@Result(name="success",location="init.jsp"),
@Result(name="failure",location="/index.jsp")
public String login(){
String username=request.getParameter("username");
String password=request.getParameter("password");
Userinfo userinfo=
userinfo = userinfoService.findlogin(username, password);
} catch (Exception e) {
e.printStackTrace();
if(userinfo==null){
request.setAttribute("msg", "用户名或密码错误");
return "failure";
request.getSession().setAttribute("userid", userinfo.getUserid());
return "success";
public boolean used(String userid,String url) {
List&?& list=
list = userinfoService.used(userid, url);
} catch (Exception e) {
e.printStackTrace();
if(list!=null&&!list.isEmpty()){
public void setServletResponse(HttpServletResponse response) {
this.response=
public void setServletRequest(HttpServletRequest request) {
this.request=
public UserinfoService getUserinfoService() {
return userinfoS
public void setUserinfoService(UserinfoService userinfoService) {
this.userinfoService = userinfoS
package com.sshFrame.zero.action.
import javax.servlet.http.HttpServletR
import javax.servlet.http.HttpServletR
import org.apache.struts2.convention.annotation.A
import org.apache.struts2.convention.annotation.N
import org.apache.struts2.convention.annotation.ParentP
import org.apache.struts2.convention.annotation.R
import org.apache.struts2.interceptor.ServletRequestA
import org.apache.struts2.interceptor.ServletResponseA
import org.springframework.beans.factory.annotation.A
import org.springframework.context.annotation.S
import com.opensymphony.xwork2.ActionS
import com.sshFrame.zero.service.users.UserinfoS
* @author 雪精灵
@Namespace("/admin")
@ParentPackage("default")
@Scope("prototype")
public class AdminAction extends ActionSupport implements ServletRequestAware,ServletResponseAware{
private static final long serialVersionUID = 1L;
@Autowired
private UserinfoService userinfoS
private HttpServletR
private HttpServletR
@Action(value="init",results={@Result(name="success",location="main.jsp"),
@Result(name="failure",location="/index.jsp")})
public String init(){
String userid=(String) request.getSession().getAttribute("userid");
System.out.println(userid);
return SUCCESS;
public UserinfoService getUserinfoService() {
return userinfoS
public void setUserinfoService(UserinfoService userinfoService) {
this.userinfoService = userinfoS
public void setServletResponse(HttpServletResponse response) {
this.response=
public void setServletRequest(HttpServletRequest request) {
this.request=
下面加入拦截器
package com.sshFrame.zero.
import javax.servlet.http.HttpServletR
import org.apache.struts2.ServletActionC
import com.opensymphony.xwork2.A
import com.opensymphony.xwork2.ActionI
import com.opensymphony.xwork2.interceptor.AbstractI
import com.sshFrame.zero.action.users.UserinfoA
import com.sshFrame.zero.exception.AhCustomE
import com.sshFrame.zero.exception.AhCustomException.ExcC
* 用户权限拦截器，在struts.xml中配置
* @author 雪精灵
public class AuthorityInterceptor extends AbstractInterceptor{
private static final long serialVersionUID = 9842225L;
private UserinfoAction userinfoA
public String intercept(ActionInvocation invocation) throws Exception {
HttpServletRequest request = ServletActionContext.getRequest();
String method = invocation.getProxy().getMethod();
String actionName=invocation.getInvocationContext().getName();
String userid = (String) request.getSession().getAttribute("userid");
if(userid==null||"".equals(userid)){
request.setAttribute("msg",AhCustomException.getExcMessage(ExcCode.Unlogined));
return Action.ERROR;
//获取项目路径
String contextPath=request.getServletContext().getContextPath();
//获取当前路径
String uri = request.getRequestURI();
//当前相对项目的路径
String actionUrl=uri.replace(contextPath, "");
boolean used = userinfoAction.used(userid, actionUrl);
return invocation.invoke();
request.setAttribute("msg",AhCustomException.getExcMessage(ExcCode.InvalidRights));
return Action.ERROR;
public UserinfoAction getUserinfoAction() {
return userinfoA
public void setUserinfoAction(UserinfoAction userinfoAction) {
this.userinfoAction = userinfoA
package com.sshFrame.zero.
import javax.servlet.http.HttpServletR
import org.apache.log4j.L
import org.apache.struts2.ServletActionC
import org.hibernate.HibernateE
import com.opensymphony.xwork2.A
import com.opensymphony.xwork2.ActionI
import com.opensymphony.xwork2.interceptor.AbstractI
import com.sshFrame.zero.exception.AhCustomE
import com.sshFrame.zero.exception.AhCustomException.ExcC
* 错误权限拦截器，在struts.xml中配置
* @author 雪精灵
public class ExceptionInterceptor extends AbstractInterceptor{
private Logger logger=Logger.getLogger(ExceptionInterceptor.class);
private static final long serialVersionUID = -7683231L;
private String excMessage="";
public String intercept(ActionInvocation invocation) throws Exception {
HttpServletRequest request = ServletActionContext.getRequest();
String uri = request.getRequestURI();
result = invocation.invoke();
} catch (HibernateException e) {
e.printStackTrace();
logger.error("异常拦截器拦截到异常:"+"&br/&"+"uri为:"+uri+"&br/&"+e);
excMessage=AhCustomException.getExcMessage(ExcCode.DataProcessing);
request.setAttribute("msg", excMessage);
result=Action.ERROR;
}catch (NullPointerException e) {
e.printStackTrace();
logger.error("异常拦截器拦截到异常:"+"&br/&"+"action的名称为:"+uri+"&br/&"+e);
excMessage=AhCustomException.getExcMessage(ExcCode.IllegalData);
request.setAttribute("msg", excMessage);
result=Action.ERROR;
}catch (AhCustomException e) {
e.printStackTrace();
logger.error("异常拦截器拦截到异常:"+"&br/&"+"action的名称为:"+uri+"&br/&"+e);
excMessage=e.getExcMessage();
request.setAttribute("msg", excMessage);
result=Action.ERROR;
}catch (Exception e) {
e.printStackTrace();
logger.error("异常拦截器拦截到异常:"+"&br/&"+"action的名称为:"+uri+"&br/&"+e);
excMessage=AhCustomException.getExcMessage(ExcCode.AppError);
request.setAttribute("msg", excMessage);
result=Action.ERROR;
自定义异常类
package com.sshFrame.zero.
* 自定义异常处理
* @author 雪精灵
public class AhCustomException extends Exception{
private static final long serialVersionUID = 1L;
* 错误类型标识
private ExcCode excCode =
public enum ExcCode{
InvalidRights,
IllegalData,
DataProcessing,
public static final String[] excMessage = {
"内部异常",
"您没有执行本操作的权限",
"提供的数据为空或不合法",
"数据处理异常",
"您可能还没有登录本系统，或者已经超时，您必须先登录本系统后才能使用该功能&p&&a href='../' target='_parent'&重新登录&/a&&/p&"
public AhCustomException(){
super(getExcMessage(ExcCode.AppError));
excCode = ExcCode.AppE
* 构造函数
* @param arg0
错误类型标识
public AhCustomException(ExcCode excCode) {
super(getExcMessage(excCode));
this.excCode = excC
* 根据错误类型标识获取错误信息
* @param emFlag
错误类型标识
* @return 错误信息
public static String getExcMessage(ExcCode excCode) {
return excMessage[excCode.ordinal()];
public String getExcMessage() {
return excMessage[excCode.ordinal()];
* 构造函数
* @param arg0
错误类型标识
* @param arg1
被包含的异常对象
public AhCustomException(ExcCode excCode, Throwable throwable) {
super(getExcMessage(excCode), throwable);
setStackTrace(throwable.getStackTrace());
this.excCode = excC
* 构造函数
* @param arg0
被包含的异常对象
public AhCustomException(Throwable throwable) {
super(getExcMessage(throwable.getClass() == AhCustomException.class ? ((AhCustomException) throwable).excCode : ExcCode.AppError), throwable);
setStackTrace(throwable.getStackTrace());
if (throwable.getClass() == AhCustomException.class)
excCode = ((AhCustomException) throwable).excC
excCode = excCode.AppE
下面加入页面，index.jsp,在webContent下
&%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%&
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
&!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"&
&base href="&%=basePath%&"&
&title&My JSP 'index.jsp' starting page&/title&
&meta http-equiv="pragma" content="no-cache"&
&meta http-equiv="cache-control" content="no-cache"&
&meta http-equiv="expires" content="0"&
&meta http-equiv="keywords" content="keyword1,keyword2,keyword3"&
&meta http-equiv="description" content="This is my page"&
&link rel="stylesheet" type="text/css" href="styles.css"&
&form action="login" method="post"&
&tr&&td&用户名：&/td&&td&&input type="text" name="username"/&&/td&&/tr&
&tr&&td&密码：&/td&&td&&input type="password" name="password"/&&/td&&/tr&
&tr&&td colspan="2"&&input type="submit" value="Login"/&&/td&&/tr&
init.jsp.在web-inf/content/下
&%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%&
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
&!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"&
&base href="&%=basePath%&"&
&title&My JSP 'init.jsp' starting page&/title&
&meta http-equiv="pragma" content="no-cache"&
&meta http-equiv="cache-control" content="no-cache"&
&meta http-equiv="expires" content="0"&
&meta http-equiv="keywords" content="keyword1,keyword2,keyword3"&
&meta http-equiv="description" content="This is my page"&
&link rel="stylesheet" type="text/css" href="styles.css"&
&script type="text/javascript"&
window.onload=function(){
window.location.href="admin/init";
程序下载链接：
我想问一下为什么service调用dao的时候，一定要加@Autowired呢？不加就空指针，能解释一下吗？
自动注入，dao，主要把当前注入的到给basedao，否则，basedao为null
happysnowcity
浏览: 9253 次
来自: 天津
&div class=&quote_title ...
我想问一下为什么service调用dao的时候，一定要加@Au ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'