spring04 数据库操作 spring+jdbc/hibernate 及其声明式事务处理

来源：互联网发布：阿里云华南地区是哪里编辑：程序博客网时间：2024/06/05 10:29

一、 spring+jdbc

1、jdbc编程的特点：
模板编程：固定代码+动态的参数

2、jdbcDaoSupport,JdbcTemplate,JdbcAccessor的结构类图

3、spring结合jdbc引入datasource的三种方式
1、让自己写的一个dao类继承JdbcDaoSupport
2、让自己写的一个dao类继承JdbcTemplate
3、让自己写的一个dao类里有一个属性为JdbcTemplate

4、总结：
1、引入dataSource的方式：
1、在dataSource的设置中直接写值
2、引入properties文件
2、在dao的写法中有很多种，最终只需要把dataSource注入到jdbcTemplate中
注：需要导入dbcp的数据源jar包和mysql的数据库驱动包还有springjdbc.properties文件


5、所需配置文件信息：
---------------------------------------------------------------------------------
springjdbc.properties:
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/数据库名称
jdbc.username=root
jdbc.password=密码


applicationContext.xml:
<bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<value>classpath:springjdbc.properties的路径</value>
</property>
</bean>
<bean id="dataSource" destroy-method="close"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>

// 引入dao层的bean

---------------------------------------------------------------------------------

例1-方式1：让自己写的一个dao类继承JdbcDaoSupport
-----------------------------------------------------------------------
类：
public class PersonDao1 extends JdbcDaoSupport {
// 注：在此处可以覆盖好多dao操作的方法
public void update(){
this.getJdbcTemplate().execute("update person set pname='p1' where pid='1'");
}
}

配置文件：
springjdbc.properties:
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/数据库名称
jdbc.username=root
jdbc.password=密码


applicationContext.xml:
<bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<value>classpath:springjdbc.properties的路径</value>
</property>
</bean>
<bean id="dataSource" destroy-method="close"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>

<bean id="personDao1" class="cn.itcast.springjdbc.manyStyle.PersonDao1">
<property name="dataSource">
<ref bean="dataSource"/>
</property>
</bean>

测试：
public class PersonDaoTest {
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("
cn/itcast/springjdbc/manyStyle/applicationContext.xml");
PersonDao1 personDao = (PersonDao1) context.getBean("personDao1");
personDao.update();
}
}
-----------------------------------------------------------------------


例2-方式2：让自己写的一个dao类继承JdbcTemplate
-----------------------------------------------------------------------
类：
public class PersonDao2 extends JdbcTemplate{
public PersonDao2(DataSource dataSource){
super(dataSource);
}
public void update(){
this.execute("update person set pname='p2' where pid='2'");
}
}

配置文件：
springjdbc.properties:
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/数据库名称
jdbc.username=root
jdbc.password=密码

applicationContext.xml:
<bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<value>classpath:springjdbc.properties的路径</value>
</property>
</bean>
<bean id="dataSource" destroy-method="close"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>

<bean id="personDao2" class="cn.itcast.springjdbc.manyStyle.PersonDao2">
<constructor-arg index="0" ref="dataSource"></constructor-arg>
</bean>


测试：
public class PersonDaoTest {
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("
cn/itcast/springjdbc/manyStyle/applicationContext.xml");
PersonDao2 personDao = (PersonDao2) context.getBean("personDao2");
personDao.update();
}
}
-----------------------------------------------------------------------

例3-方式3：让自己写的一个dao类里有一个属性为JdbcTemplate
-----------------------------------------------------------------------
类：
public class PersonDao3 {
private JdbcTemplate jdbcTemplate;
// set/get属性
public void update(){
this.jdbcTemplate.execute("update person set pname='p3' where pid='3'");
}
}

配置文件：
springjdbc.properties:
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/数据库名称
jdbc.username=root
jdbc.password=密码


applicationContext.xml:
<bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<value>classpath:springjdbc.properties的路径</value>
</property>
</bean>
<bean id="dataSource" destroy-method="close"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource">
<ref bean="dataSource"/>
</property>
</bean>
<bean id="personDao3" class="cn.itcast.springjdbc.manyStyle.PersonDao3">
<property name="jdbcTemplate">
<ref bean="jdbcTemplate"/>
</property>
</bean>

测试：
public class PersonDaoTest {
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("
cn/itcast/springjdbc/manyStyle/applicationContext.xml");
PersonDao3 personDao = (PersonDao3) context.getBean("personDao3");
personDao.update();
}
}

-----------------------------------------------------------------------

6、spring结合Jdbc查询

原理：创建一个类，实现RowMapper接口，覆盖mapRow()方法
创建目标类，继承JdbcDaoSupport接口，覆盖query方法，查询

例：
---------------------------------------------------------------------------
public class Person implements Serializable {
private Long pid;
private String pname;
// set/get属性
}

public class PersonRowMapper implements RowMapper {
@Override
public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
Person person = new Person();
person.setPid(rs.getLong("pid"));
person.setPname(rs.getString("pname"));
return person;
}
}

public class PersonDao extends JdbcDaoSupport {
public void query(){
List<Person> persons = this.getJdbcTemplate().query("
select * from person", new PersonRowMapper());
for (Person person : persons) {
System.out.println(person.getPname());
}
}
}

配置文件：
springjdbc.properties:
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/数据库名称
jdbc.username=root
jdbc.password=密码


applicationContext.xml:
<bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<value>classpath:springjdbc.properties的路径</value>
</property>
</bean>
<bean id="dataSource" destroy-method="close"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>

<bean id="personDao" class="cn.itcast.springjdbc.query.PersonDao">
<property name="dataSource">
<ref bean="dataSource"/>
</property>
</bean>

测试：
public class PersonDaoTest {
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("
cn/itcast/springjdbc/query/applicationContext.xml");
PersonDao personDao = (PersonDao) context.getBean("personDao");
personDao.query();
}
}

---------------------------------------------------------------------------

二、 spring声明式事务处理


1、概念：
spring
声明：针对的是程序员，程序员告诉spring容器，哪些方法需要事务，哪些方法不需要事务
事务处理： spring容器来做事务处理

2.目的：让spring管理事务，开发者不再关注事务
spring容器来做事务处理(开启事务提交事务回滚事务)；开发者： crud
代理对象:代理方法：spring管理的事务+开发者的crud

3、声明式事务类图(DataSourceTransaction、AbstreacTransactionManager、PlatformTransactionManager)

4、spring声明式事务处理的步骤：
1、搭建环境
2、把dao层和service层的接口和类写完
3、在spring的配置文件中，先导入dataSource
4、测试（注意要每步都测）
5、导入dao和service层的bean
6、测试（注意要每步都测）
7、进行AOP的配置
1、引入事务管理器
2、进行aop的配置
8、测试service层的类看是否是代理对象

5、spring结合jdbc声明式事务处理例子
例：
----------------------------------------------------------------------------
public class Person implements Serializable {
private Long pid;
private String pname;
private String psex;
// set/get属性
}


public interface PersonDao {
public void savePerson();
public List<Person> getPerson();
}


// 注：结合jdcb则继承JdbcDaoSupport
public class PersonDaoImpl extends JdbcDaoSupport implements PersonDao {
@Override
public List<Person> getPerson() {
return this.getJdbcTemplate().query("select * from person", new RowMapper() {
@Override
public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
Person person = new Person();
person.setPid(rs.getLong("pid"));
person.setPname(rs.getString("pname"));
person.setPsex(rs.getString("psex"));
return person;
}
});
}

@Override
public void savePerson() {
this.getJdbcTemplate().update("insert into person(pname,psex) values('小雪','女')");
}
}

public interface PersonService {
public void savePerson();
public List<Person> getPerson();
}


public class PersonServiceImpl implements PersonService {

private PersonDao personDao;
// set/get属性

@Override
public List<Person> getPerson() {
return this.personDao.getPerson();
}

@Override
public void savePerson() {
this.personDao.savePerson();
// 用来测试是否有事务，如果有的话，则有异常，要回滚，该记录无法插入数据库
// int a = 1/0;
}
}


public class MyException {
public void myException(Throwable ex){
System.out.println(ex.getMessage());
}
}


配置文件：
springjdbc.properties:
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/springaop
jdbc.username=root
jdbc.password=123456

applicationContext.xml:

<bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<value>classpath:springjdbc.properties</value>
</property>
</bean>
<bean id="dataSource" destroy-method="close"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>

<bean id="personDao" class="cn.itcast.dao.impl.PersonDaoImpl">
<property name="dataSource">
<ref bean="dataSource"/>
</property>
</bean>
<bean id="personService" class="cn.itcast.service.impl.PersonServiceImpl">
<property name="personDao">
<ref bean="personDao"/>
</property>
</bean>
<bean id="myException" class="cn.itcast.exception.MyException"></bean>




<bean id="transactionManager" class="
org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource">
<ref bean="dataSource"/>
</property>
</bean>


<tx:advice id="tx" transaction-manager="transactionManager">
<tx:attributes>

<tx:method name="save*" read-only="false"/>
</tx:attributes>
</tx:advice>


<aop:config>

<aop:pointcut expression="execution(* cn.itcast.service.impl.*.*(..))" id="perform"/>

<aop:advisor advice-ref="tx" pointcut-ref="perform"/>

<aop:aspect ref="myException">
<aop:after-throwing method="myException" pointcut-ref="perform" throwing="ex"/>
</aop:aspect>
</aop:config>


测试：
public class ManyTest {

public static ApplicationContext context;
static{
context = new ClassPathXmlApplicationContext("applicationContext.xml");
}

@Test
public void getDatasource(){
context.getBean("dataSource");
}

@Test
public void getPersonDao(){
context.getBean("personDao");
}

@Test
public void getPersonService(){
//注：此处必须测试，personService必须为jdk代理对象，才有事务
PersonService personService = (PersonService) context.getBean("personService");
System.out.println(personService);

personService.savePerson();
}
}
----------------------------------------------------------------------------

6、spring结合hibernate声明式事务处理的例子
例：
------------------------------------------------------------------------------

public class Person implements Serializable {
private Long pid;
private String pname;
private String psex;
// set/get属性
}


public interface PersonDao {
public void savePerson(Person person);
}


// 注：此处要继承hibernateDaoSupport
public class PersonDaoImpl extends HibernateDaoSupport implements PersonDao {
@Override
public void savePerson(Person person) {
this.getHibernateTemplate().save(person);
}
}


public interface PersonService {
public void savePerson(Person person);
}

public class PersonServiceImpl implements PersonService {
private PersonDao personDao;
// set/get属性

@Override
public void savePerson(Person person) {
this.personDao.savePerson(person);
}
}

配置文件：
springjdbc.properties:
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/springaop
jdbc.username=root
jdbc.password=123456

applicationContext.xml:
<bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<value>classpath:springjdbc.properties</value>
</property>
</bean>
<bean id="dataSource" destroy-method="close"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>




<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation">
<value>classpath:hibernate.cfg.xml</value>
</property>
</bean>


<bean id="personDao" class="cn.itcast.sth.dao.impl.PersonDaoImpl">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>
<bean id="personService" class="cn.itcast.sth.service.impl.PersonServiceImpl">
<property name="personDao">
<ref bean="personDao"/>
</property>
</bean>


<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>
<tx:advice id="tx" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" read-only="false"/>
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut expression="execution(* cn.itcast.sth.service.impl.*.*(..))" id="perform"/>
<aop:advisor advice-ref="tx" pointcut-ref="perform"/>
</aop:config>


测试：
public class ConfigTest {
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
// 注：此处生成的为代理对象
PersonService personService = (PersonService) context.getBean("personService");
Person person = new Person();
person.setPname("sth");
personService.savePerson(person);
}
}

------------------------------------------------------------------------------

0 0