应用Spring和Hibernate（C3P0数据池）写数据库交互项目

一、xml的配置文件（application.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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
          destroy-method="close">
        <property name="driverClass" value="com.mysql.jdbc.Driver" />
        <property name="jdbcUrl"
                  value="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=utf-8" />
        <property name="user" value="root" />
        <property name="password" value="root" />
        <property name="maxPoolSize" value="20" />
        <property name="minPoolSize" value="1" />
        <property name="initialPoolSize" value="1" />
        <property name="maxIdleTime" value="20" />
    </bean>

    <bean id="sessionFactory"
          class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="packagesToScan">
            <list>
                <value>com.zxc.po</value>
            </list>
        </property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.current_session_context_class">org.springframework.orm.hibernate5.SpringSessionContext
                </prop>
            </props>
        </property>
    </bean>
    <bean id="transactionManager"
          class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <aop:pointcut expression="execution(* com.zxc.service.*Impl.*(..))"
                      id="zxcpointcut"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="zxcpointcut"/>
    </aop:config>
    <bean id="userService" class="com.zxc.service.UserServiceImpl">
        <property name="dao" ref="dao"/>
    </bean>
    <bean id="dao" class="com.weikun.zxc.UserDAOHibernate">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
</beans>

datasource标签配置数据库的链接，此处使用的是C3P0，也可以换成dbcp，但是使用德鲁伊时候要另外使用ini配置文件。

sessionFatory标签配置回话工厂，将datasource数据库连接放入工厂中，设置好其自动扫描的po层的包（用list标签，值用value），然后设置Hibernate的配置

transactionManager标签配置事务管理，tx标签专门配置事务管理。

aop:config用来配置aop

二、dao层

　　

package com.zxc.dao;

import com.zxc.po.PageBean;
import com.zxc.po.User;
import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.query.Query;
import java.util.Iterator;
import java.util.List;
public class UserDAOHibernate {
    private SessionFactory sessionFactory;

    public SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

//    static{
//        Configuration configuration=new Configuration().configure("hibernate.cfg.xml");
//        sf=configuration.buildSessionFactory();
//    }不用每次都写这段话了,有AOP的配置，所以每次运行到UserServiceImpl类中的方法时，自动在方法前进行sessionfactory的创建

    public UserDAOHibernate(){

    }

    public PageBean queryAll(int pageNo,int pageSize){
        PageBean page =new PageBean();
        Session session=sessionFactory.openSession();
        Query q=session.createQuery("from User as a order by a.id desc");
        q.setCacheable(true);
        q.setFirstResult((pageNo-1)*pageSize);
        q.setMaxResults(pageSize);
        List<User> list=q.list();

        page.setPageNo(pageNo);//当前页
        page.setPageSize(pageSize);//每页多少行

        page.setList(list);//当前页数据
        q=session.createQuery("select count(*) from User as a");
        List list1=q.list();
        Iterator it=list1.iterator();

        while(it.hasNext()){
            Object o=it.next();
            page.setMaxCount(new Integer(o.toString()).intValue());//一共多少行
        }

        page.setMaxPage((int)Math.ceil(page.getMaxCount()/page.getPageSize()));//最大页数

        session.close();
        return page;
    }
    public boolean addUser(User user){
        Session session=sessionFactory.openSession();
        boolean flag=false;
        Transaction transaction=session.beginTransaction();
        try {
            session.save(user);
            transaction.commit();
            flag=true;
        }catch(Exception e){
            transaction.rollback();
            e.printStackTrace();
        }finally{
            session.close();
        }

        return flag;
    }
    public boolean delUser(String id){
        boolean flag=false;
        Session session=sessionFactory.openSession();
        Transaction transaction=session.beginTransaction();
        try {
            User user=session.load(User.class,Integer.parseInt(id));
            session.delete(user);
            transaction.commit();
            flag=true;
        }catch(Exception e){
            transaction.rollback();
            e.printStackTrace();
        }finally{
            session.close();
        }

        return flag;
    }
    public boolean updateUser(User user){
        boolean flag=false;
        Session session=sessionFactory.openSession();
        Transaction transaction=session.beginTransaction();
        try {
            session.saveOrUpdate(user);
            transaction.commit();
            flag=true;
        }catch(Exception e){
            transaction.rollback();
            e.printStackTrace();
        }finally{
            session.close();
        }

        return flag;

    }
    public User queryUserById(String id){
        Session session=sessionFactory.openSession();
        User user=session.load(User.class,Integer.parseInt(id));
        if (!Hibernate.isInitialized(user)){
            Hibernate.initialize(user);
        }
        session.close();

        return user;

    }
}

三、service层

　　

package com.zxc.service;
import com.zxc.dao.UserDAOHibernate;
import com.zxc.po.PageBean;
import com.zxc.po.User;
import java.util.List;
public class UserServiceImpl {
    private UserDAOHibernate dao;//;=new UserDAOHibernate();

    public UserDAOHibernate getDao() {
        return dao;
    }

    public void setDao(UserDAOHibernate dao) {
        this.dao = dao;
    }

    public boolean addUser(User user){
        return dao.addUser(user);
    }
    public User queryUserById(String id){
        return dao.queryUserById(id);
    }
    public boolean delUser(String id){

        return dao.delUser(id);
    }
    public PageBean queryAll(int pageNo, int pageSize){

        return dao.queryAll(pageNo,pageSize);
    }
    public boolean updateUser(User user){

        return dao.updateUser(user);
    }
}

四、control层

　　InitControl类用来当spring总大脑，管理servlet，创建getBean类，

package com.zxc.control;
import org.springframework.context.ApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
@WebServlet(name = "initControl",urlPatterns = {"/init"},loadOnStartup =1 )
public class InitControl extends HttpServlet{
    private static ApplicationContext ctx=null;
    @Override
    public void init() throws ServletException {
        ctx= WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());//加载本身的配置文件web.xml
    }
    public static Object getBean(String beanName){
        return ctx.getBean(beanName);
    }
}

userControl类

package com.zxc.control;

import com.alibaba.fastjson.JSON;
import com.zxc.po.PageBean;
import com.zxc.po.User;
import com.zxc.service.UserServiceImpl;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
@WebServlet(
        name = "userControl",urlPatterns = {"/user"}
)
public class UserControl extends HttpServlet{
    private UserServiceImpl service=(UserServiceImpl)InitControl.getBean("userService");
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req,resp);
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String action=req.getParameter("action");

        switch (action){
            case "query":
                String pageNo=req.getParameter("no");//当前页
                int pageSize=2;
                PageBean pageBean=service.queryAll(Integer.parseInt(pageNo),pageSize);//每次页面的数据传过来，还需要传输pagebean
                resp.setContentType("text");
                resp.setCharacterEncoding("utf-8");
                String json=JSON.toJSON(pageBean).toString();
                System.out.println(json);
                PrintWriter out=resp.getWriter();
                out.print(json);
                out.flush();
                out.close();
                break;
            case "del":
                String id=req.getParameter("id");
                service.delUser(id);
                break;
            case "add":
                String myid=req.getParameter("myid");
                User user=new User();
                user.setUsername(req.getParameter("username"));
                user.setPassword(req.getParameter("password"));

                if(!myid.equals("")){//修改
                    user.setId(Integer.parseInt(myid));
                    service.updateUser(user);
                    break ;
                }

                service.addUser(user);

                break;
            case "up"://通过主键 定位本条记录
                id=req.getParameter("id").toString();
                user=service.queryUserById(id);
                resp.setContentType("text");
                resp.setCharacterEncoding("utf-8");
                json=JSON.toJSONString(user);//

                out=resp.getWriter();
                out.print(json);
                out.flush();
                out.close();
                break;
            default:
                break;
        }
    }
}

web.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
    <context-param>
        <param-name>
            contextConfigLocation
        </param-name>
        <param-value>
            classpath*:applicationContext.xml
        </param-value>
    </context-param>
    <listener>
        <!-- Application context=new ClassPathXmlApplicationConext() -->
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <welcome-file-list>
        <welcome-file>index.html</welcome-file>
    </welcome-file-list>
</web-app>

以上是spring配置web项目时的xml配置方法，welcom-file-list标签用来设置初始页面，context-parme用来设置容器配置文件