`

SSH下使用Spring注解自动注入bean

 
阅读更多

Spring注解的使用方法详见:http://www.ibm.com/developerworks/cn/java/j-lo-spring25-ioc/,这里在SSH框架下做一个例子。

首先导入相关包:spring-beans-3.0.4.RELEASE.jar(org.springframework.beans.factory.annotation.Autowired用来注入bean)、spring-context-3.0.4.RELEASE.jar(org.springframework.stereotype.Componet 、Service、Repository等用来定义bean)。

其次需要添加相关配置:applicationContext.xml

 

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  3.     xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"  
  4.     xmlns:context="http://www.springframework.org/schema/context"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">  
  6.   
  7.     <description>Spring公共配置 </description>  
  8.   
  9.     <!-- 配置数据源 -->  
  10.     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
  11.         <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>  
  12.         <property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:cui"/>  
  13.         <property name="username" value="cui"/>  
  14.         <property name="password" value="cui"/>  
  15.     </bean>  
  16.       
  17.     <!-- 配置sessionFactory -->  
  18.     <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">  
  19.         <property name="dataSource" ref="dataSource"/>  
  20.         <property name="hibernateProperties">  
  21.             <props>  
  22.                 <prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>  
  23.                 <prop key="hibernate.show_sql">true</prop>  
  24.             </props>  
  25.         </property>  
  26.         <property name="packagesToScan">  
  27.             <list>  
  28.                 <value>com.entity</value>  
  29.             </list>  
  30.         </property>  
  31.     </bean>  
  32.       
  33.     <!-- 事务管理 -->  
  34.     <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
  35.         <property name="sessionFactory" ref="sessionFactory"></property>  
  36.     </bean>  
  37.       
  38.     <!-- 使用annotation自动注入bean,并启动相关处理注解的进程 -->  
  39.     <context:component-scan base-package="com">  
  40.         <context:include-filter type="regex" expression="com/.dao.*"/>  
  41.         <!-- 正则表达式必须格式正确,否则无效。以下是无效的示例  
  42.         <context:exclude-filter type="regex" expression="/.service/..*"/>  
  43.         <context:exclude-filter type="regex" expression="com/.service*"/>  
  44.         <context:exclude-filter type="regex" expression=".service*"/>  
  45.          -->  
  46.          <!-- 正确格式:从base-package开始  
  47.          <context:exclude-filter type="regex" expression="com/.service.*"/>  
  48.          <context:exclude-filter type="regex" expression="com/.service/..*"/>  
  49.           -->  
  50.     </context:component-scan>  
  51.   
  52. </beans>  

 

web.xml

 

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">  
  3.     <display-name>mytest</display-name>  
  4.     <!-- 指定spring配置文件的位置 -->  
  5.     <context-param>  
  6.         <param-name>contextConfigLocation</param-name>  
  7.         <param-value>classpath*:/applicationContext.xml</param-value>  
  8.     </context-param>  
  9.       
  10.     <!-- Struts 2 -->  
  11.     <filter>  
  12.         <filter-name>struts2</filter-name>  
  13.         <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>  
  14.         <init-param>  
  15.             <param-name>actionPackages</param-name>  
  16.             <param-value>com.action</param-value>  
  17.         </init-param>  
  18.     </filter>  
  19.   
  20.     <filter-mapping>  
  21.         <filter-name>struts2</filter-name>  
  22.         <url-pattern>/*</url-pattern>  
  23.     </filter-mapping>  
  24.       
  25.     <!-- 自动加载applicationContext -->  
  26.     <listener>  
  27.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
  28.     </listener>  
  29. </web-app>  

 

使用Hibernate JPA定义User类:

 

  1. package com.entity;  
  2.   
  3. import javax.persistence.Column;  
  4. import javax.persistence.Entity;  
  5. import javax.persistence.GeneratedValue;  
  6. import javax.persistence.GenerationType;  
  7. import javax.persistence.Id;  
  8. import javax.persistence.Table;  
  9.   
  10. @Entity  
  11. @Table(name = "s_user")  
  12. public class User {  
  13.   
  14.     private Long id;  
  15.     private String username;  
  16.     private String password;  
  17.   
  18.     @Id  
  19.     @GeneratedValue(strategy = GenerationType.AUTO)  
  20.     public Long getId() {  
  21.         return id;  
  22.     }  
  23.   
  24.     public void setId(Long id) {  
  25.         this.id = id;  
  26.     }  
  27.   
  28.     @Column(name = "name")  
  29.     public String getUsername() {  
  30.         return username;  
  31.     }  
  32.   
  33.     public void setUsername(String username) {  
  34.         this.username = username;  
  35.     }  
  36.   
  37.     @Column(name = "pwd")  
  38.     public String getPassword() {  
  39.         return password;  
  40.     }  
  41.   
  42.     public void setPassword(String password) {  
  43.         this.password = password;  
  44.     }  
  45.   
  46. }  

 

Dao层:

 

  1. package com.dao;  
  2.   
  3. import com.entity.User;  
  4.   
  5. public interface UserDao {  
  6.     public void save(User user);  
  7. }  
  8.   
  9.   
  10. package com.dao.Impl;  
  11.   
  12. import org.apache.commons.logging.Log;  
  13. import org.apache.commons.logging.LogFactory;  
  14. import org.hibernate.SessionFactory;  
  15. import org.springframework.beans.factory.annotation.Autowired;  
  16. import org.springframework.orm.hibernate3.HibernateTemplate;  
  17. import org.springframework.stereotype.Repository;  
  18.   
  19. import com.dao.UserDao;  
  20. import com.entity.User;  
  21.   
  22. @Repository("userDao")  
  23. public class UserDaoImpl implements UserDao {  
  24.   
  25.     private HibernateTemplate template;  
  26.     private Log log = LogFactory.getLog(UserDaoImpl.class);  
  27.   
  28.     //使用构造子注入自动注入sessionFactory   
  29.     @Autowired  
  30.     public UserDaoImpl(SessionFactory sessionFactory) {  
  31.         this.template = new HibernateTemplate(sessionFactory);  
  32.     }  
  33.   
  34.     public void save(User user) {  
  35.         template.save(user);  
  36.         log.debug("save user:" + user.getUsername());  
  37.     }  
  38. }  

 

Service层:

 

  1. package com.service;  
  2. import com.entity.User;  
  3.   
  4. public interface UserManager {  
  5.     public void add(User user);  
  6. }  
  7.   
  8.   
  9. package com.service.Impl;  
  10.   
  11. import org.apache.commons.logging.Log;  
  12. import org.apache.commons.logging.LogFactory;  
  13. import org.springframework.beans.factory.annotation.Autowired;  
  14. import org.springframework.stereotype.Service;  
  15.   
  16. import com.dao.UserDao;  
  17. import com.entity.User;  
  18. import com.service.UserManager;  
  19.   
  20. @Service("userManager")  
  21. public class UserManagerImpl implements UserManager {  
  22.   
  23.     //自动注入userDao,也可以使用@Resource   
  24.     @Autowired  
  25.     private UserDao userDao;  
  26.     private Log log = LogFactory.getLog(UserManagerImpl.class);  
  27.   
  28.     public void add(User user) {  
  29.         userDao.save(user);  
  30.         log.debug("add User:" + user.getUsername());  
  31.     }  
  32. }  

 

Action:

 

  1. package com.action.convention;  
  2.   
  3. import org.apache.struts2.convention.annotation.Result;  
  4. import org.springframework.beans.factory.annotation.Autowired;  
  5.   
  6. import com.entity.User;  
  7. import com.opensymphony.xwork2.ActionSupport;  
  8. import com.service.UserManager;  
  9.   
  10. @Result(name = "success", location = "hello.jsp")  
  11. public class UserAction extends ActionSupport {  
  12.   
  13.     private static final long serialVersionUID = 1L;  
  14.   
  15.     @Autowired  
  16.     private UserManager userManager;  
  17.   
  18.     public String execute() {  
  19.         User user = new User();  
  20.         user.setUsername("cuihaiyang");  
  21.         user.setPassword("abcd");  
  22.   
  23.         userManager.add(user);  
  24.   
  25.         return SUCCESS;  
  26.     }  
  27. }  

 

调试信息如下:

Hibernate: select hibernate_sequence.nextval from dual
Hibernate: insert into s_user (pwd, name, id) values (?, ?, ?)
2011-03-10 19:44:25,296 [http-8080-1] DEBUG [com.dao.Impl.UserDaoImpl] - save user:cuihaiyang
2011-03-10 19:44:25,296 [http-8080-1] DEBUG [com.service.Impl.UserManagerImpl] - add User:cuihaiyang

 

转自http://blog.csdn.net/cuihaiyang/article/details/6238257#

分享到:
评论

相关推荐

    ssh框架构建 hibernate注解 spring注解

    Spring注解如`@Component`、`@Service`、`@Repository`和`@Controller`用于标记bean,使得Spring容器能够自动检测和管理这些bean。此外,`@Autowired`注解用于自动装配bean的依赖,而`@Transactional`注解则可以声明...

    SSH使用spring注解实现登陆源代码

    SSH(Struts2、Spring、Hibernate)...总的来说,这个项目提供了一个使用SSH框架和Spring注解实现的登录功能实例,通过分析和学习,你可以更好地理解SSH框架的工作原理以及如何在实际项目中应用Spring注解来简化开发。

    SSH全注解实例详解,hibernate,struts,spring

    在实际开发中,SSH框架的使用往往结合IDE(如Eclipse或IntelliJ IDEA)进行,这些工具通常有对SSH支持的插件,能帮助开发者快速生成和管理注解配置。同时,持续集成工具(如Jenkins)和版本控制系统(如Git)也是...

    ssh注解开发案例

    - `服务类和服务接口`:使用Spring注解进行配置的服务层类和接口。 - `DAO类`:使用Hibernate和Spring注解进行数据访问操作的类。 - `测试类`:用于验证注解配置是否正确的测试代码。 - `web.xml`:Web应用的部署...

    SSH注解方式整合小例子

    3. **配置DAO**:使用Spring的`@Repository`注解标记DAO接口,通常会配合`@Autowired`注入SessionFactory或EntityManager。 4. **服务层**:使用`@Service`注解标记服务类,这里会包含业务逻辑,同样可以使用`@...

    SSH高质量整合.Spring注解标签,项目启动自动建表.

    综上所述,SSH高质量整合利用Spring的注解简化配置,通过Hibernate的注解实现ORM映射,同时利用Hibernate的自动建表功能,极大地提高了开发效率。项目中的标签注入则优化了视图层的开发,使得整个Web应用的开发流程...

    spring注解方式解析

    在上面的例子中,`@Service`注解标记了UserService是一个业务层组件,而`@Autowired`注解告诉Spring容器自动寻找与userRepository类型匹配的bean进行注入。Spring会通过类型匹配、名称匹配或者使用@Qualifier注解...

    SSH注解小实例

    在Spring中,我们可以通过注解来声明bean、依赖注入、事务管理等。比如,`@Component` 定义了一个bean,`@Autowired` 自动装配bean的依赖,`@Transactional` 实现了事务管理。 **Hibernate** 是一个强大的ORM...

    ssh2框架整合,struts2和hibernate均交由spring管理,用注解的方式由spring注入

    例如,可以通过`@Resource`或`@Autowired`注解在类成员变量上,让Spring自动寻找匹配类型的bean进行注入。另外,`@Component`、`@Service`、`@Repository`和`@Controller`等注解用于定义不同类型的bean,`@Scope`...

    Spring注解配置中间层供Struts2使用

    总结起来,这个场景展示了如何通过Spring注解配置创建和管理中间层服务,以及如何在不依赖Struts2默认配置的情况下,使Struts2能够使用这些服务。通过这种方式,我们可以充分利用Spring的注解驱动和依赖注入能力,...

    ssh代码整合基于注解方式的

    `@Autowired`注解可以自动将Bean注入到需要的字段或方法中。例如: ```java @Service public class UserService { private UserRepository userRepository; @Autowired public UserService(UserRepository ...

    ssh环境搭建+注解配置

    在SSH2中,Spring主要负责控制层和业务层的管理,通过注解配置可以避免大量的XML配置文件,例如`@Autowired`用于自动装配bean,`@Service`、`@Repository`和`@Controller`用于标记服务、数据访问对象和控制器类。...

    spring注解实例

    学习这个实例,你可以了解到如何在实际项目中利用Spring注解来提高代码可读性、减少配置,并了解SSH2架构下Spring如何与其他组件协同工作。同时,通过阅读文档,你可以深入理解每个注解的用法和背后的设计理念,...

    ssh 框架注解示例

    "ssh"文件夹可能包含了示例项目的源代码,包括Struts2的Action类、Hibernate的实体类、Spring的配置文件等,这些都是深入理解SSH框架和注解使用的宝贵学习资料。 总之,SSH框架结合了Struts2的请求处理、Hibernate...

    SSH2整合全注解实例

    SSH2整合全注解实例是基于Struts2、Spring和Hibernate这三个开源框架的集成应用,它们共同构建了一个强大的Web应用程序开发平台。SSH2是Java Web开发中的经典组合,提供了模型-视图-控制器(MVC)的设计模式,使得...

    SSH框架全注解项目案例

    2. **Spring注解**: - `@Component`:标记一个类为Spring管理的Bean,如Service、DAO等。 - `@Autowired`:自动装配Bean,根据类型或名称注入依赖。 - `@Qualifier`:配合@Autowired,当有多个相同类型的Bean时...

    SSH整合,纯注解,包含事务,零配置

    在本项目中,Spring通过注解实现组件扫描,自动装配Bean,如`@Autowired`用于自动注入依赖,`@Service`、`@Repository`和`@Controller`定义不同层的组件角色。此外,Spring的AOP机制用于事务管理,如`@Transactional...

    ssh-使用注解

    - `@Autowired`:这个注解用于自动装配Bean,Spring会根据类型或名称将依赖注入到目标Bean中。 - `@Component`,`@Service`,`@Repository`:这些是组件扫描的注解,它们标识了一个类作为Spring的Bean,分别对应于...

    java和ssh注解

    2. **Spring**:Spring框架是注解驱动的王者,它提供了大量的注解来实现依赖注入(DI)、AOP、事务管理等功能。比如,@Autowired自动装配bean,@Service、@Repository、@Controller用于组件扫描,@Transactional进行...

    SSH框架非注解版所需要的jar包

    SSH框架,全称为Spring、Struts和Hibernate的组合,是Java Web开发中广泛使用的三大开源框架。它们分别负责应用的依赖注入(Spring)、MVC(Model-View-Controller)架构管理(Struts)以及持久层操作(Hibernate)...

Global site tag (gtag.js) - Google Analytics