整合初步--------->SSH（注解版）

时间：2022-01-27 07:58:03

上面的一篇博客已经介绍了 Spring和Hibernate之间的整合，没看过的童鞋可以去看看，这篇博客讲解Spring+Hibernate+Struts2注解版。。。。。。。。。

个人觉得使用注解可能更方便一点，就是在灵活性上不好把控，当方法特别多的时候，使用事务来进行管理时，就会消耗内存，从而造成浪费。如果使用AOP方式来进行管理，就可以指定我哪些方法进行怎样的操作，会减少内存的消耗。

使用注解，首先你要知道你需要哪些支持（就是jar包），找不对就会出现jar包冲突的情况，我在刚开始时经常出现这种情况，这就需要你一定的基础，熟悉各个框架之间需要连接的桥梁。今天讲解的示例，使用的是以下jar包：

    <dependencies>

        <!--测试 jar包-->

        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>4.3</version>

        </dependency>

        <!--spring jar包

          带有一系列的jar包

          例如：core ，expression，beans，context，aop-->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context</artifactId>

            <version>4.3..RELEASE</version>

        </dependency>

        <!--spring web jar 包-->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-web</artifactId>

            <version>4.3..RELEASE</version>

        </dependency>

        <!--spring-tx jar 包-->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-tx</artifactId>

            <version>4.3..RELEASE</version>

        </dependency>

        <!--spring-ormjar 包

          整合所需jar包-->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-orm</artifactId>

            <version>4.3..RELEASE</version>

        </dependency>

        <!--spring-jdbcjar 包-->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-jdbc</artifactId>

            <version>4.3..RELEASE</version>

        </dependency>

        <!--aspectJ jar 包-->

        <dependency>

            <groupId>org.aspectj</groupId>

            <artifactId>aspectjweaver</artifactId>

            <version>1.8.</version>

        </dependency>

        <dependency>

            <groupId>log4j</groupId>

            <artifactId>log4j</artifactId>

            <version>1.2.</version>

        </dependency>

        <!--commons-dncpjar 包

          数据源

        -->

        <dependency>

            <groupId>org.apache.commons</groupId>

            <artifactId>commons-dbcp2</artifactId>

            <version>2.1.</version>

        </dependency>

        <!--<dependency>

            <groupId>commons-dbcp</groupId>

            <artifactId>commons-dbcp</artifactId>

            <version>1.4</version>

        </dependency>-->

        <!--c3p0jar 包-->

        <dependency>

            <groupId>c3p0</groupId>

            <artifactId>c3p0</artifactId>

            <version>0.9.1.2</version>

        </dependency>

        <!--struts2-spring-plugin jar 包

          整合所需插件包

        -->

        <dependency>

            <groupId>org.apache.struts</groupId>

            <artifactId>struts2-spring-plugin</artifactId>

            <version>2.5.</version>

        </dependency>

        <!--struts2 core 包  核心包-->

        <dependency>

            <groupId>org.apache.struts</groupId>

            <artifactId>struts2-core</artifactId>

            <version>2.5.</version>

        </dependency>

        <!--使用注解action jar包-->

        <dependency>

            <groupId>org.apache.struts</groupId>

            <artifactId>struts2-convention-plugin</artifactId>

            <version>2.5.</version>

        </dependency>

        <!--hibernate jar 包-->

        <dependency>

            <groupId>org.hibernate</groupId>

            <artifactId>hibernate-core</artifactId>

            <version>5.0..Final</version>

        </dependency>

        <!--jtajar 包-->

        <dependency>

            <groupId>javax.transaction</groupId>

            <artifactId>jta</artifactId>

            <version>1.1</version>

        </dependency>

        <!--mysql数据库驱动-->

        <dependency>

            <groupId>org.wisdom-framework</groupId>

            <artifactId>mysql-connector-java</artifactId>

            <version>5.1.34_1</version>

        </dependency>

        <!--oraclejar 包-->

        <!--<dependency>

            <groupId>com.oracle</groupId>

            <artifactId>ojdbc6</artifactId>

            <version>11.2.0.1.</version>

        </dependency>-->

        <!--jstl jar包-->

        <dependency>

            <groupId>org.apache.taglibs</groupId>

            <artifactId>taglibs-standard-spec</artifactId>

            <version>1.2.</version>

        </dependency>

        <dependency>

            <groupId>org.apache.taglibs</groupId>

            <artifactId>taglibs-standard-impl</artifactId>

            <version>1.2.</version>

        </dependency>

        <!--mybatis jar包-->

        <!-- <dependency>

             <groupId>org.mybatis</groupId>

             <artifactId>mybatis</artifactId>

             <version>3.4.</version>

         </dependency>-->

        <!--servlet api包-->

        <dependency>

            <groupId>javax.servlet</groupId>

            <artifactId>servlet-api</artifactId>

            <version>2.5</version>

        </dependency>

    </dependencies>

    <build>

        <resources>

            <resource>

                <directory>src/main/java</directory>

                <includes>

                    <include>**/*.xml</include>

                    <include>**/*.properties</include>

                </includes>

            </resource>

        </resources>

    </build>

</project>

在这里说明一点：有时候项目可能识别不到你编写的xml文件和properties文件时，你就需要加上<build></build>节点里面的内容，

这样编译器就会编译了，童鞋们要记住呦！

项目的整体架构：

整合初步--------->SSH（注解版）

使用idea的好处就是，架构特别清晰，什么层干什么活，不会出现混乱的情况，当你的架构调理不清楚时，启动测试时就会出现各种错误，这里吐槽一下：idea有时候报错不会报到具体的错误，这点就不好，也在于我学的不精，基础太差，呵呵，小小的抱怨一下。

当我们所需要的jar包准备完毕后，就可以开始搭建我们的架构了。

beans类的书写：

package cn.note.beans;

import javax.persistence.Column;

import javax.persistence.GeneratedValue;

import javax.persistence.Id;

import javax.persistence.Table;

/**

 * Created by accp on 2017/3/31.

 */

@Table

public class Book {

    @Id

    @GeneratedValue

    private Integer id;

    @Column

    private String name;

    @Column

    private String price;

    public Book() {

    }

    public Book(String name, String price) {

        this.name = name;

        this.price = price;

    }

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getPrice() {

        return price;

    }

    public void setPrice(String price) {

        this.price = price;

    }

}

dao层的书写:主要定义方法原型，编写SQL语句，访问数据库，获得数据，传递给biz层，进行之后的判断

dao：

package cn.note.dao;

import cn.note.beans.Book;

import java.util.List;

/**

 * Created by accp on 2017/3/31.

 */

public interface IBookDao {

    /*查询，用作登录*/

    int select(Book book);

    /*查询所有的图书*/

    List<Book>  selectAll();

 }

dao层的实现层impl：

package cn.note.dao.impl;

import cn.note.beans.Book;

import cn.note.dao.IBookDao;

import org.hibernate.Criteria;

import org.hibernate.SessionFactory;

import org.hibernate.criterion.Restrictions;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Repository;

import org.springframework.transaction.annotation.Isolation;

import org.springframework.transaction.annotation.Propagation;

import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**

 * Created by accp on 2017/3/31.

 */

/*标识这个是dao层*/

@Repository

public class BookDaoImpl implements IBookDao {

    /*使用自动注入属性*/

    @Autowired

    private SessionFactory sessionFactory;

    /*标识哪些方法进行事务的管理，从而进行如何的操作*/

    @Transactional

    public int select(Book book) {

        /*

        * 页面上根据传递过来的数据进行装配

        * */

        Criteria criteria = sessionFactory.getCurrentSession().createCriteria(Book.class)

                .add(Restrictions.eq("name",book.getName())).add(Restrictions.eq("price", book.getPrice()));

        List<Book> list = criteria.list();

        if (list != null) {

            return ;

        }

        return ;

    }

    /*标识哪些方法进行事务的管理，从而进行如何的操作*/

    @Transactional(isolation = Isolation.DEFAULT,propagation = Propagation.REQUIRED)

    public List<Book> selectAll() {

        /*获取全部的图书信息*/

        return sessionFactory.getCurrentSession().createSQLQuery("SELECT  * from book").list();

    }

    public SessionFactory getSessionFactory() {

        return sessionFactory;

    }

    public void setSessionFactory(SessionFactory sessionFactory) {

        this.sessionFactory = sessionFactory;

    }

}

biz层主要是进行一些逻辑判断时所在的层面。

biz的方法：

package cn.note.biz;

import cn.note.beans.Book;

import java.util.List;

/**

 * Created by accp on 2017/3/31.

 */

public interface IBookBiz {

    int select(Book book);

    List<Book> selectAll();

}

方法的实现类：

package cn.note.biz.impl;

import cn.note.beans.Book;

import cn.note.biz.IBookBiz;

import cn.note.dao.IBookDao;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**

 * Created by accp on 2017/3/31.

 */

/*标识这是biz层*/

@Service("bookBiz")

public class BookBizImpl implements IBookBiz {

    /*自动注入属性*/

    @Autowired

    private IBookDao dao;

    public int select(Book book) {

        return dao.select(book);

    }

    public List<Book> selectAll() {

        return dao.selectAll();

    }

    public IBookDao getDao() {

        return dao;

    }

    public void setDao(IBookDao dao) {

        this.dao = dao;

    }

}

当我写到这的时候，不禁想到，这个画面我好像似曾相识，原来这就是你写了好多遍的情况，这些代码已经记录在你的手指上了，不需要你的大脑思考，你就会不知不觉的把它编写出来，这就像是老朋友，多年未见，感情依然。。。

还是让我们继续吧，生活的脚步跟上。。。。。。。。

接下来就是action类的编写，这个层主要是获取从页面上传来的数据，进行判断，之后该进行哪些操作，这个层面就会用到struts2框架的功能，Struts2是一个基于MVC设计模式的Web应用框架，它本质上相当于一个servlet，在MVC设计模式中，Struts2作为控制器(Controller)来建立模型与视图的数据交互。Struts 2是Struts的下一代产品，是在 struts 1和WebWork的技术基础上进行了合并的全新的Struts 2框架。其全新的Struts 2的体系结构与Struts 1的体系结构差别巨大。Struts 2以WebWork为核心，采用拦截器的机制来处理用户的请求，这样的设计也使得业务逻辑控制器能够与ServletAPI完全脱离开，所以Struts 2可以理解为WebWork的更新产品。虽然从Struts 1到Struts 2有着太大的变化，但是相对于WebWork，Struts 2的变化很小。

LoginAction类的编写:

package cn.note.action;

import cn.note.beans.Book;

import cn.note.biz.IBookBiz;

import com.opensymphony.xwork2.ActionSupport;

import org.apache.struts2.ServletActionContext;

import org.apache.struts2.convention.annotation.*;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.Scope;

import org.springframework.stereotype.Controller;

import javax.servlet.http.HttpServletRequest;

import java.util.List;

/**

 * Created by accp on 2017/3/31.

 */

/*标识action层

* scope：管理action生成的是多例还是单例

* ：prototype 和 singleton

* Namespace:命名空间

* 默认继承哪个包

* */

@Controller

@Scope("prototype")

@Namespace("/")

@ParentPackage("struts-default")

public class LoginAction extends ActionSupport{

    /*自动注入属性*/

    @Autowired

    private IBookBiz biz;

    @Override

    /*value:跟你表单提交到的action逻辑名称对应

    * className:为action指定别名

    * */

    @Action(value = "login",results = {@Result(name = "success",location = "/success.jsp"),

            @Result(name = "input",location = "/index.jsp")},className = "loginAction")

    public String execute() throws Exception {

        HttpServletRequest request = ServletActionContext.getRequest();

        /*获取页面上输入的名称*/

        String name = request.getParameter("name");

        /*获取页面上输入的价格*/

        String price = request.getParameter("price");

        Book book=new Book(name,price);

        int count = biz.select(book);

        if(count>){

            List<Book> list = biz.selectAll();

           request.getSession().setAttribute("list",list);

            return SUCCESS;

        }else{

            return INPUT;

        }

    }

    public IBookBiz getBiz() {

        return biz;

    }

    public void setBiz(IBookBiz biz) {

        this.biz = biz;

    }

}

写到这里，我们的工程就差不多完成一大半了，即将登上高峰，加把劲。。。。。

接下来开始编写xml文件吧，把这些繁琐的工作做完我们才能见到彩虹，现在正在听《阳光总在风雨后》，唱的真好。

2017年4月5日17:06:46

xml文件：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:aop="http://www.springframework.org/schema/aop"

       xmlns:context="http://www.springframework.org/schema/context"

       xmlns:tx="http://www.springframework.org/schema/tx"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="

       http://www.springframework.org/schema/beans

       http://www.springframework.org/schema/beans/spring-beans.xsd

       http://www.springframework.org/schema/context

       http://www.springframework.org/schema/context/spring-context.xsd

       http://www.springframework.org/schema/tx

       http://www.springframework.org/schema/tx/spring-tx.xsd

       http://www.springframework.org/schema/aop

       http://www.springframework.org/schema/aop/spring-aop.xsd

">

    <!--注册jdbc-->

     <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

    <!--添加数据源-->

    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">

        <property name="driverClassName" value="${jdbc.driver}"/>

        <property name="url" value="${jdbc.url}"/>

        <property name="username" value="${jdbc.username}"/>

        <property name="password" value="${jdbc.password}"/>

    </bean>

    <!--配置sessionFactory-->

    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">

        <property name="dataSource" ref="dataSource"></property>

        <property name="hibernateProperties">

            <props>

                <!--方言-->

                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>

                <!--打印sql-->

                <prop key="hibernate.show_sql">true</prop>

                <!--格式化sql-->

                <prop key="hibernate.format_sql">true</prop>

                <prop key="hbm2ddl.auto">update</prop>

                <!--获取线程内的变量-->

                <prop key="hibernate.current_session_context_class">org.springframework.orm.hibernate5.SpringSessionContext</prop>

            </props>

        </property>

        <!--<property name="mappingDirectoryLocations" value="classpath:cn/happy/beans"></property>-->

    </bean>

    <context:component-scan base-package="cn.note"></context:component-scan>

    <!--bean dao-->

    <!--<bean id="bookDao" class="cn.happy.dao.impl.BookDaoImpl">

        <property name="factory" ref="sessionFactory"></property>

    </bean>-->

    <!--bean biz-->

   <!-- <bean id="bookBiz" class="cn.happy.biz.impl.BookBizImpl">

        <property name="dao" ref="bookDao"/>

    </bean>-->

    <!--action-->

    <!--<bean id="login" class="cn.happy.action.LoginAction">

        <property name="biz" ref="bookBiz"></property>

    </bean>-->

    <!--配置事务-->

    <!--第一步配置事务管理器-->

    <!--<bean id="txManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">

        <property name="sessionFactory" ref="sessionFactory"></property>

    </bean>

    <tx:advice id="txAdvice" transaction-manager="txManager">

        <tx:attributes>

            <tx:method name="selectAll" propagation="REQUIRED"/>

        </tx:attributes>

    </tx:advice>-->

    <!--配置事务管理器-->

    <bean id="txManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">

        <property name="sessionFactory" ref="sessionFactory"></property>

    </bean>

    <!--注解驱动-->

    <tx:annotation-driven transaction-manager="txManager"></tx:annotation-driven>

</beans>

jdbc.properties文件：

jdbc.driver=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql:///y2163

jdbc.username=root

jdbc.password=

想想写到这里我们还缺少什么，有没有什么遗漏，我们先来理一下思路：当用户请求页面，填写完数据，点击提交，就会根据指定的action地址，action内部机制（FilterDispatcher）会做出一些判断，去寻找相应的action，根据携带的一些数据，调取相应的方法去完成这个工作，完成一系列的判断工作之后，携带数据返回。

下面的图解会更清晰一点：

整合初步--------->SSH（注解版）

看到这个，我就想起我刚理解这个的那会儿，老大难问题，好了废话不多说了，还是回归正题吧，看到这里我就想到在web.xml中也需要配置一下，因为在整合中struts2充当的是拦截器的角色，需要配置：

<!--配置filter-->

  <filter>

    <filter-name>struts2</filter-name>

    <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>

  </filter>

  <filter-mapping>

    <filter-name>struts2</filter-name>

    <url-pattern>/*</url-pattern>

  </filter-mapping>

想想还得配置让项目认到你配置的xml文件：

<!--指定路径-->

  <context-param>

    <param-name>contextConfigLocation</param-name>

    <param-value>classpath:applicationContextnote.xml</param-value>

  </context-param>

在配置一道监听器：

<!--配置监听器-->

  <listener>

    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

  </listener>

上面我们也说到要配置xml文件，这些做完之后，就可以搭建我们的页面了

index.jsp:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<html>

<head>

    <title>登录页面</title>

</head>

<body>

<form method="post" action="login">

    用户名：<input name="name"/><br>

    密码：<input name="price"/><br>

    <input type="submit" value="提交"/><br>

</form>

</body>

</html>

success.jsp:

<%@ taglib prefix="s" uri="/struts-tags" %>

<%@ taglib prefix="c" uri="/struts-tags" %>

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>

<html>

<head>

    <title>成功页面</title>

</head>

<body>

success!!!!!!!!

<s:debug></s:debug>

${list}

</html>

整体的 一个项目就这样完成了，写下来因为没那么难，看你自己的掌握程度，多多联系，相信自己。

现在自己听的歌：《霸王别姬》2017年4月5日17:45:49

好了，登顶。

下期再见。。。。。。

相关文章