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

上面的一篇博客已经介绍了 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>节点里面的内容，

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

项目的整体架构：

使用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，根据携带的一些数据，调取相应的方法去完成这个工作，完成一系列的判断工作之后，携带数据返回。

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

看到这个，我就想起我刚理解这个的那会儿，老大难问题，好了废话不多说了，还是回归正题吧，看到这里我就想到在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

好了，登顶。

下期再见。。。。。。