（SSH学习笔记三）SSH之JDBC集成与实现

前端框架中服务端分为表现层，业务逻辑层以及数据处理层，本节主要记录下数据处理层的具体实现。

数据处理层想要访问数据库获取数据，需要以下几步：

1.加载数据库驱动：mysql数据库驱动为org.gjt.mm.mysql.Driver

2.获取数据库连接对象：Connection conn = DriverManager.getConnection(URL,USERNAME,PASSWORD);

3.获取将执行sql发送给database的对象： PreparedStatement ps = conn.prepareStatement("执行sql");

4.获取处理结果

传统的数据处理是如何做的？

package com.sts.javaIoc.action;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class JdbcTest {

	private static final String DRIVER_NAME = "org.gjt.mm.mysql.Driver";
	private static final String URL = "jdbc:mysql://47.93.51.25:3306/drp_db";
	private static final String USERNAME = "root";
	private static final String PASSWORD = "Sauser#123";
	public static void main(String[] args) {
		queryItem();
	}
	
	private static void queryItem() {
		Connection conn = null ;
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			//加载驱动
			Class.forName(DRIVER_NAME);
			//获取连接对象
			conn= DriverManager.getConnection(URL, USERNAME, PASSWORD);
			//将sql语句发送至database
			ps = conn.prepareStatement("select * from t_sys_user");
			//获取结果集
			rs = ps.executeQuery();
			//遍历结果集
			while (rs.next()) {
				System.out.println(rs.getInt("id"));
				System.out.println(rs.getString("account"));
				System.out.println("-----------");
			}
		} catch (Exception e) {
			// 异常处理
			e.printStackTrace();
		}
		finally {
			//释放资源，关闭连接
			try {
				if(rs != null) {
					rs.close();
				}
				if(ps != null) {
					ps.close();
				}
				if(conn != null) {
					conn.close();
				}
			} catch (Exception e2) {
				// TODO: handle exception
			}
			
		}

	}
}

可以看到，传统的数据库访问连接对象的创建以及维护都是有程序自己负责，存在很大的问题就是连接的频繁建立与释放，而SSH是如何做的呢？

在SSH中，提供了commons-dbcp2-xxx.jar包以及spring-jdbc-xxx.jar来管理数据库连接，具体实现直接看代码

第一步、修改配置文件applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
       
       <bean id="iocService" class="com.sts.javaIoc.service.impl.IocServiceImpl">
       		<!-- <property name="iocDao" ref="iocDao"></property> -->
       		<property name="iocDao" ref="iocDao"></property>
       </bean>
       <bean id="iocDao" class="com.sts.javaIoc.dao.impl.IocDaoImpl">
       		<property name="jdbcTemplete" ref="jdbcTemplete"></property>
       </bean>
       <bean id="logInfoFilter" class="com.sts.javaIoc.aop.LogInfoFilter">
       </bean>
       
       <!-- 数据源  -->
       <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
       		<property name="driverClassName" value="org.gjt.mm.mysql.Driver"></property>
       		<property name="url" value="jdbc:mysql://127.0.0.1:3306/drp_db"></property>
       		<property name="username" value="root"></property>
       		<property name="password" value="123456"></property>
       </bean>
       
        <!-- spring封装之后的JDBC模板，用于执行sql-->
       <bean id="jdbcTemplete" class="org.springframework.jdbc.core.JdbcTemplate">
       		<property name="dataSource" ref="dataSource"></property>
       </bean>
       
       
</beans>

创建一个action类，用户调用业务层对象

package com.sts.javaIoc.action;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.sts.javaIoc.service.IocService;

public class IocAction {

	public static void main(String[] args) {
		//装载配置文件
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		IocService iocService =(IocService) ac.getBean("iocService");
		iocService.execute();
	}
}

创建业务层接口

package com.sts.javaIoc.service;

public interface IocService {
	
	void execute();
}

业务层实现类

package com.sts.javaIoc.service.impl;

import com.sts.javaIoc.dao.IocDao;
import com.sts.javaIoc.service.IocService;

public class IocServiceImpl implements IocService {

	private IocDao iocDao;
	
	public void setIocDao(IocDao iocDao) {
		this.iocDao = iocDao;
	}
	
	public IocServiceImpl() {
		System.out.println("IocServiceImpl create");
	}
	
	@Override
	public void execute() {
		iocDao.execute();
	}
	
}

数据处理层接口

package com.sts.javaIoc.dao;

public interface IocDao {
	public void execute();
}

数据处理成实现类

package com.sts.javaIoc.dao.impl;

import java.util.List;
import java.util.Map;

import org.springframework.jdbc.core.JdbcTemplate;

import com.sts.javaIoc.dao.IocDao;

public class IocDaoImpl implements IocDao {
	
	private JdbcTemplate jdbcTemplete;
	
	public void setJdbcTemplete(JdbcTemplate jdbcTemplete) {
		this.jdbcTemplete = jdbcTemplete;
	}
	
	
	@Override
	public void execute() {
		List<Map<String, Object>> queryForList = jdbcTemplete.queryForList("select * from t_sys_user");
		if(queryForList == null || queryForList.size() ==0) {
			
			System.out.println("查询无结果！");
		}
		else {
			for (Map<String, Object> map : queryForList) {
				System.out.println(map);
			}
		}
	}
}

上面就实现了SSH中进行数据访问中的查询功能，可以看出来数据连接对象的创建及维护都是由SSH自己来维护，程序只需要获取执行sql的操作对象jdbcTemplete进行数据操作即可，至于资源及连接的释放就交由SSH中的IOC容器来管理了。

程序中使用到的jar包有：

aopalliance-1.0.jar               //AOP依赖包
aspectjweaver-1.9.1.jar       //AOP依赖包
commons-dbcp2-2.5.0.jar    // 数据源依赖包
commons-logging-1.2.jar     //日志依赖包，
commons-pool2-2.6.0.jar    //连接池依赖包
mysql-connector-java-5.1.22.jar  //mysql驱动包
spring-aop-4.3.13.RELEASE.jar  //AOP依赖包
spring-aspects-4.3.13.RELEASE.jar //AOP依赖包
spring-beans-4.3.13.RELEASE.jar   
spring-context-4.3.13.RELEASE.jar   
spring-context-support-4.3.13.RELEASE.jar
spring-core-4.3.13.RELEASE.jar
spring-expression-4.3.13.RELEASE.jar
spring-jdbc-4.3.13.RELEASE.jar
spring-tx-4.3.13.RELEASE.jar   //事务依赖包