- 浏览: 941056 次
- 性别:
- 来自: 重庆
文章分类
- 全部博客 (453)
- Windows phone 7 (0)
- Andriod (47)
- iPhone (1)
- Web (30)
- J2EE (34)
- stucts 2学习笔记 (34)
- 开发项目 (3)
- spring学习笔记 (24)
- EJB学习笔记 (6)
- Hibernate学习笔记 (15)
- JPA学习笔记 (8)
- Jsp (11)
- ajax (7)
- 异常收集模块 (1)
- jquery (2)
- phoneGap (2)
- jquery Mobile (0)
- java面试总结 (5)
- Object-C (0)
- javascript (6)
- Eclipse (5)
- 支付集成 (2)
- Weblogic (1)
- Dubbox (5)
- Redis (10)
- linux (21)
- Codis (2)
- React Native (0)
- Mysql (6)
- Docker (3)
- 自动化部署 (1)
- 项目Bug管理平台 (2)
- 负载均衡 (1)
- Mycat (2)
- Java基础知识 (16)
- 数据库 (7)
- Maven (17)
- Kafka (21)
- logs (2)
- 大并发 (2)
- 消息中间件 (2)
- 分布式锁 (3)
- 算法 (4)
- 数字证书原理,公钥私钥 (0)
- 数字证书原理 (1)
- 公钥私钥 (1)
- zookeeper (4)
- Hbase (9)
- Hadoop (2)
- storm (2)
- 通信协议 (1)
- Hive (3)
- git (1)
- JVM (2)
- 大数据相关算法 (1)
- idea (5)
- 将博客搬至CSDN (1)
- 设计模式 (2)
- 表达式 (1)
- 代码审查工具 (0)
- 开源项目 (1)
- PyCharm (0)
- python (6)
- Kubernetes (1)
- swagger (1)
- Maven中mirrors和repository的关系 (0)
- RabbitMQ (3)
- redisson (1)
- k8s (2)
- Mac (1)
最新评论
-
misisipi101:
假设库已经分为32个,那么要扩展到64个,怎样做呢
订单分库分表实践总结以及关键步骤 -
mfkxk298:
简单明了的例子,解决了问题,谢谢啦!
关于ListView中notifyDataSetChanged()刷新数据不更新原因 -
whbwang:
" target="_blank" ...
java web开发 高并发处理 -
suguoqian:
...
java web开发 高并发处理 -
xiangnanyujing:
Dubbox+Redis3.0+Spring+Hibernate+zookeeper实现消息推送核心搭建
知识点;
【
<1、使用Spring+JDBC集成步骤如下:
配置数据源,如:
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="org.gjt.mm.mysql.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/itcast?useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
.....略
</bean>
配置事务。配置事务时,需要在xml配置文件中引入用于声明事务的tx命名空间(见下页),事务的配置方式有两种:注解方式和基于XML配置方式。
在spring配置文件中引入用于声明事务的tx命名空间:
<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:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
</beans>
<2、配置数据源:
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="org.gjt.mm.mysql.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/itcast?useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
<!-- 连接池启动时的初始值 -->
<property name="initialSize" value="1"/>
<!-- 连接池的最大值 -->
<property name="maxActive" value="500"/>
<!-- 最大空闲值.当经过一个高峰时间后,连接池可以慢慢将已经用不到的连接慢慢释放一部分,一直减少到maxIdle为止 -->
<property name="maxIdle" value="2"/>
<!-- 最小空闲值.当空闲的连接数少于阀值时,连接池就会预申请去一些连接,以免洪峰来时来不及申请 -->
<property name="minIdle" value="1"/>
</bean>
使用<context:property-placeholder location=“jdbc.properties”/>属性占位符
<3、使用属性占位符方式配置数据源:
<context:property-placeholder location=“jdbc.properties”/>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="${driverClassName}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
<!-- 连接池启动时的初始值 -->
<property name="initialSize" value="${initialSize}"/>
<!-- 连接池的最大值 -->
<property name="maxActive" value="${maxActive}"/>
<!-- 最大空闲值.当经过一个高峰时间后,连接池可以慢慢将已经用不到的连接慢慢释放一部分,一直减少到maxIdle为止 -->
<property name="maxIdle" value="${maxIdle}"/>
<!-- 最小空闲值.当空闲的连接数少于阀值时,连接池就会预申请去一些连接,以免洪峰来时来不及申请 -->
<property name="minIdle" value="${minIdle}"/>
</bean>
<4、采用注解方式配置事务:
采用注解方式
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<!– 采用@Transactional注解方式使用事务 -->
<tx:annotation-driven transaction-manager="txManager"/>
@Service @Transactional
public class PersonServiceBean implements PersonService {
}
<5、采用基于XML方式配置事务:
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<aop:config>
<aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
</aop:config>
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
<tx:method name="*"/>
</tx:attributes>
</tx:advice>
<6、使用JdbcTemplate进行insert/update/delete操作:
@Service @Transactional
public class PersonServiceBean implements PersonService {
private JdbcTemplate jdbcTemplate;
@Resource
public void setDataSource(DataSource dataSource) {
this.jdbcTemplate = new JdbcTemplate(dataSource);
}
//添加
public void save(Person person) throws Exception{
jdbcTemplate.update("insert into person (name) values(?)",
new Object[]{person.getName()}, new int[]{java.sql.Types.VARCHAR});
}
}
<7、使用JdbcTemplate获取一条记录:
@Service @Transactional
public class PersonServiceBean implements PersonService {
private JdbcTemplate jdbcTemplate;
@Resource
public void setDataSource(DataSource dataSource) {
this.jdbcTemplate = new JdbcTemplate(dataSource);
}
public Person getPerson(Integer id){
RowMapper rowMapper = new RowMapper(){
public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
Person person = new Person();
person.setId(rs.getInt("id"));
person.setName(rs.getString("name"));
return person;
}
};
return (Person)jdbcTemplate.queryForObject("select * from person where id=?",
new Object[]{id}, new int[]{java.sql.Types.INTEGER}, rowMapper);
}}
<8、使用JdbcTemplate获取多条记录:
@Service @Transactional
public class PersonServiceBean implements PersonService {
private JdbcTemplate jdbcTemplate;
@Resource
public void setDataSource(DataSource dataSource) {
this.jdbcTemplate = new JdbcTemplate(dataSource);
}
public List<Person> getPersons(){
RowMapper rowMapper = new RowMapper(){
public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
Person person = new Person();
person.setId(rs.getInt("id"));
person.setName(rs.getString("name"));
return person;
}
};
return jdbcTemplate.query("select * from person", rowMapper);
}
】
准备工作导入以下*.jar包
commons-dbcp.jar,commons-logging.jar,commons-pool.jar,spring.jar
commons-annotations.jar,mysql-connector-jarva-3.2.0-alpha-bin.jar
第一步:安装以上知识点搭建环境其中beans.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:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<!-- 配置数据源 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="org.gjt.mm.mysql.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/student?useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="liyong"/>
<!-- 连接池启动时的初始值 -->
<property name="initialSize" value="1"/>
<!-- 连接池的最大值 -->
<property name="maxActive" value="500"/>
<!-- 最大空闲值.当经过一个高峰时间后,连接池可以慢慢将已经用不到的连接慢慢释放一部分,一直减少到maxIdle为止 -->
<property name="maxIdle" value="2"/>
<!-- 最小空闲值.当空闲的连接数少于阀值时,连接池就会预申请去一些连接,以免洪峰来时来不及申请 -->
<property name="minIdle" value="1"/>
</bean>
<!-- 配置事务管理 -->
<tx:annotation-driven transaction-manager="txManager"/>
<!-- 指定这个事务管理的数据源 -->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
</beans>
第二步:编写一个java bean 类
public class Person {
private int id;
private String name;
public Person(){}
public Person(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
第三步:编写业务类及实现的接口
IPersonService。java PersonService。java
public interface IPersonService {
public abstract void add(int id,String name);
public abstract void delete(String name);
public abstract Person getObject(String name);
public abstract List<Person> getObjects();
}
@Transactional//这里表示这个类交个spring事务管理其中每个方法都在同一个事务中
public class PersonService implements IPersonService {
private DataSource source;//我们最好不好直接使用数据源使用JdbcTemplate来操作
private JdbcTemplate template;
public void setSource(DataSource source) {
this.template=new JdbcTemplate(source);
}
public void add(int id,String name)
{
template.update("insert into studentinfo(number,name)values(?,?)",new Object[]{id,name});
}
public void delete(String name)
{
template.update("delete from studentinfo where name=?",new Object[]{name});
}
public Person getObject(String name)
{
return (Person)template.queryForObject("select * from studentinfo where name=?", new Object[]{name},new int[]{java.sql.Types.VARCHAR}, new myRowMapper());
}
public List<Person> getObjects()
{
List<Person> list=template.query("select * from studentinfo", new myRowMapper());
return list;
}
}
第四步:这里是业务类中需要的一个行映射器类
public class myRowMapper implements RowMapper {
public Object mapRow(ResultSet set, int index) throws SQLException {
Person person=new Person(set.getInt("number"),set.getString("name"));
return person;
}
}
第五步:配置beans.xml文件为PersonService的属性DataSource注入值及把相应的bean交给spring
<bean id="person" class="com.liyong.bean.Person"/>
<bean id="personService" class="com.liyong.PersonService.PersonService">
<property name="source" ref="dataSource"></property>
</bean>
第六步:编写单元测试
public class PersonServiceTest {
@Test
public void TestAdd()
{
ApplicationContext cxt=new ClassPathXmlApplicationContext("beans.xml");
IPersonService service=(IPersonService)cxt.getBean("personService");
//service.add(3, "xiaowang");
// System.out.println(service.getObject("liyong").getName());
/*List<Person> list=service.getObjects();
Iterator<Person> iterator=list.iterator();
while (iterator.hasNext()) {
Person person = (Person) iterator.next();
System.out.println(person.getName());
}*/
service.delete("xiaowang");
List<Person> list=service.getObjects();
Iterator<Person> iterator=list.iterator();
while (iterator.hasNext()) {
Person person = (Person) iterator.next();
System.out.println(person.getName());
}
}
}
第七步:测试........
附:对于使用通配符和属性文件配置数据源
<?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:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<bean id="person" class="com.liyong.bean.Person"/>
<bean id="personService" class="com.liyong.PersonService.PersonService">
<property name="source" ref="dataSource"></property>
</bean>
<!-- 配置数据源 第一种-->
<!-- <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="org.gjt.mm.mysql.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/student?useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="liyong"/>-->
<!-- 连接池启动时的初始值 -->
<!-- <property name="initialSize" value="1"/>-->
<!-- 连接池的最大值 -->
<!--<property name="maxActive" value="500"/>-->
<!-- 最大空闲值.当经过一个高峰时间后,连接池可以慢慢将已经用不到的连接慢慢释放一部分,一直减少到maxIdle为止 -->
<!-- <property name="maxIdle" value="2"/>-->
<!-- 最小空闲值.当空闲的连接数少于阀值时,连接池就会预申请去一些连接,以免洪峰来时来不及申请 -->
<!-- <property name="minIdle" value="1"/>
</bean>-->
<!-- 配置事务管理 -->
<!--<tx:annotation-driven transaction-manager="txManager"/>-->
<!-- 指定这个事务管理的数据源 -->
<!--
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
-->
<!-- 配置数据源 第二种使用通配符-->
<!-- location="jdbc.properties"指定加载的属性文件 -->
<context:property-placeholder location="jdbc.properties"/>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="${driverClassName}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
<!-- 连接池启动时的初始值 -->
<property name="initialSize" value="${initialSize}"/>
<!-- 连接池的最大值 -->
<property name="maxActive" value="${maxActive}"/>
<!-- 最大空闲值.当经过一个高峰时间后,连接池可以慢慢将已经用不到的连接慢慢释放一部分,一直减少到maxIdle为止 -->
<property name="maxIdle" value="${maxIdle}"/>
<!-- 最小空闲值.当空闲的连接数少于阀值时,连接池就会预申请去一些连接,以免洪峰来时来不及申请 -->
<property name="minIdle" value="${minIdle}"/>
</bean>
</beans>
然后编写jdbc.properties属性文件
driverClassName=org.gjt.mm.mysql.Driver
url=jdbc\:mysql\://localhost\:3306/student?useUnicode\=true&characterEncoding\=UTF-8
username=root
password=liyong
initialSize=1
maxActive=500
maxIdle=2
minIdle=1
<!-- 使用xml来 配置事务 -->:
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<aop:config>
<aop:pointcut id="transactionPointcut" expression="execution(* com.liyong.PersonService..*.*(..))"/>
<!-- 当拦截到方法后发出通知 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
</aop:config>
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<!-- 以下是拦截到的方法的事务配置 get*表示也get开头都是NOT_SUPPORTED不支持事务-->
<tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
<!-- 以下表示其它的方法也默认事务 -->
<tx:method name="*"/>
</tx:attributes>
</tx:advice>
【
<1、使用Spring+JDBC集成步骤如下:
配置数据源,如:
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="org.gjt.mm.mysql.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/itcast?useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
.....略
</bean>
配置事务。配置事务时,需要在xml配置文件中引入用于声明事务的tx命名空间(见下页),事务的配置方式有两种:注解方式和基于XML配置方式。
在spring配置文件中引入用于声明事务的tx命名空间:
<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:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
</beans>
<2、配置数据源:
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="org.gjt.mm.mysql.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/itcast?useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
<!-- 连接池启动时的初始值 -->
<property name="initialSize" value="1"/>
<!-- 连接池的最大值 -->
<property name="maxActive" value="500"/>
<!-- 最大空闲值.当经过一个高峰时间后,连接池可以慢慢将已经用不到的连接慢慢释放一部分,一直减少到maxIdle为止 -->
<property name="maxIdle" value="2"/>
<!-- 最小空闲值.当空闲的连接数少于阀值时,连接池就会预申请去一些连接,以免洪峰来时来不及申请 -->
<property name="minIdle" value="1"/>
</bean>
使用<context:property-placeholder location=“jdbc.properties”/>属性占位符
<3、使用属性占位符方式配置数据源:
<context:property-placeholder location=“jdbc.properties”/>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="${driverClassName}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
<!-- 连接池启动时的初始值 -->
<property name="initialSize" value="${initialSize}"/>
<!-- 连接池的最大值 -->
<property name="maxActive" value="${maxActive}"/>
<!-- 最大空闲值.当经过一个高峰时间后,连接池可以慢慢将已经用不到的连接慢慢释放一部分,一直减少到maxIdle为止 -->
<property name="maxIdle" value="${maxIdle}"/>
<!-- 最小空闲值.当空闲的连接数少于阀值时,连接池就会预申请去一些连接,以免洪峰来时来不及申请 -->
<property name="minIdle" value="${minIdle}"/>
</bean>
<4、采用注解方式配置事务:
采用注解方式
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<!– 采用@Transactional注解方式使用事务 -->
<tx:annotation-driven transaction-manager="txManager"/>
@Service @Transactional
public class PersonServiceBean implements PersonService {
}
<5、采用基于XML方式配置事务:
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<aop:config>
<aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
</aop:config>
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
<tx:method name="*"/>
</tx:attributes>
</tx:advice>
<6、使用JdbcTemplate进行insert/update/delete操作:
@Service @Transactional
public class PersonServiceBean implements PersonService {
private JdbcTemplate jdbcTemplate;
@Resource
public void setDataSource(DataSource dataSource) {
this.jdbcTemplate = new JdbcTemplate(dataSource);
}
//添加
public void save(Person person) throws Exception{
jdbcTemplate.update("insert into person (name) values(?)",
new Object[]{person.getName()}, new int[]{java.sql.Types.VARCHAR});
}
}
<7、使用JdbcTemplate获取一条记录:
@Service @Transactional
public class PersonServiceBean implements PersonService {
private JdbcTemplate jdbcTemplate;
@Resource
public void setDataSource(DataSource dataSource) {
this.jdbcTemplate = new JdbcTemplate(dataSource);
}
public Person getPerson(Integer id){
RowMapper rowMapper = new RowMapper(){
public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
Person person = new Person();
person.setId(rs.getInt("id"));
person.setName(rs.getString("name"));
return person;
}
};
return (Person)jdbcTemplate.queryForObject("select * from person where id=?",
new Object[]{id}, new int[]{java.sql.Types.INTEGER}, rowMapper);
}}
<8、使用JdbcTemplate获取多条记录:
@Service @Transactional
public class PersonServiceBean implements PersonService {
private JdbcTemplate jdbcTemplate;
@Resource
public void setDataSource(DataSource dataSource) {
this.jdbcTemplate = new JdbcTemplate(dataSource);
}
public List<Person> getPersons(){
RowMapper rowMapper = new RowMapper(){
public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
Person person = new Person();
person.setId(rs.getInt("id"));
person.setName(rs.getString("name"));
return person;
}
};
return jdbcTemplate.query("select * from person", rowMapper);
}
】
准备工作导入以下*.jar包
commons-dbcp.jar,commons-logging.jar,commons-pool.jar,spring.jar
commons-annotations.jar,mysql-connector-jarva-3.2.0-alpha-bin.jar
第一步:安装以上知识点搭建环境其中beans.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:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<!-- 配置数据源 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="org.gjt.mm.mysql.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/student?useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="liyong"/>
<!-- 连接池启动时的初始值 -->
<property name="initialSize" value="1"/>
<!-- 连接池的最大值 -->
<property name="maxActive" value="500"/>
<!-- 最大空闲值.当经过一个高峰时间后,连接池可以慢慢将已经用不到的连接慢慢释放一部分,一直减少到maxIdle为止 -->
<property name="maxIdle" value="2"/>
<!-- 最小空闲值.当空闲的连接数少于阀值时,连接池就会预申请去一些连接,以免洪峰来时来不及申请 -->
<property name="minIdle" value="1"/>
</bean>
<!-- 配置事务管理 -->
<tx:annotation-driven transaction-manager="txManager"/>
<!-- 指定这个事务管理的数据源 -->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
</beans>
第二步:编写一个java bean 类
public class Person {
private int id;
private String name;
public Person(){}
public Person(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
第三步:编写业务类及实现的接口
IPersonService。java PersonService。java
public interface IPersonService {
public abstract void add(int id,String name);
public abstract void delete(String name);
public abstract Person getObject(String name);
public abstract List<Person> getObjects();
}
@Transactional//这里表示这个类交个spring事务管理其中每个方法都在同一个事务中
public class PersonService implements IPersonService {
private DataSource source;//我们最好不好直接使用数据源使用JdbcTemplate来操作
private JdbcTemplate template;
public void setSource(DataSource source) {
this.template=new JdbcTemplate(source);
}
public void add(int id,String name)
{
template.update("insert into studentinfo(number,name)values(?,?)",new Object[]{id,name});
}
public void delete(String name)
{
template.update("delete from studentinfo where name=?",new Object[]{name});
}
public Person getObject(String name)
{
return (Person)template.queryForObject("select * from studentinfo where name=?", new Object[]{name},new int[]{java.sql.Types.VARCHAR}, new myRowMapper());
}
public List<Person> getObjects()
{
List<Person> list=template.query("select * from studentinfo", new myRowMapper());
return list;
}
}
第四步:这里是业务类中需要的一个行映射器类
public class myRowMapper implements RowMapper {
public Object mapRow(ResultSet set, int index) throws SQLException {
Person person=new Person(set.getInt("number"),set.getString("name"));
return person;
}
}
第五步:配置beans.xml文件为PersonService的属性DataSource注入值及把相应的bean交给spring
<bean id="person" class="com.liyong.bean.Person"/>
<bean id="personService" class="com.liyong.PersonService.PersonService">
<property name="source" ref="dataSource"></property>
</bean>
第六步:编写单元测试
public class PersonServiceTest {
@Test
public void TestAdd()
{
ApplicationContext cxt=new ClassPathXmlApplicationContext("beans.xml");
IPersonService service=(IPersonService)cxt.getBean("personService");
//service.add(3, "xiaowang");
// System.out.println(service.getObject("liyong").getName());
/*List<Person> list=service.getObjects();
Iterator<Person> iterator=list.iterator();
while (iterator.hasNext()) {
Person person = (Person) iterator.next();
System.out.println(person.getName());
}*/
service.delete("xiaowang");
List<Person> list=service.getObjects();
Iterator<Person> iterator=list.iterator();
while (iterator.hasNext()) {
Person person = (Person) iterator.next();
System.out.println(person.getName());
}
}
}
第七步:测试........
附:对于使用通配符和属性文件配置数据源
<?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:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<bean id="person" class="com.liyong.bean.Person"/>
<bean id="personService" class="com.liyong.PersonService.PersonService">
<property name="source" ref="dataSource"></property>
</bean>
<!-- 配置数据源 第一种-->
<!-- <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="org.gjt.mm.mysql.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/student?useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="liyong"/>-->
<!-- 连接池启动时的初始值 -->
<!-- <property name="initialSize" value="1"/>-->
<!-- 连接池的最大值 -->
<!--<property name="maxActive" value="500"/>-->
<!-- 最大空闲值.当经过一个高峰时间后,连接池可以慢慢将已经用不到的连接慢慢释放一部分,一直减少到maxIdle为止 -->
<!-- <property name="maxIdle" value="2"/>-->
<!-- 最小空闲值.当空闲的连接数少于阀值时,连接池就会预申请去一些连接,以免洪峰来时来不及申请 -->
<!-- <property name="minIdle" value="1"/>
</bean>-->
<!-- 配置事务管理 -->
<!--<tx:annotation-driven transaction-manager="txManager"/>-->
<!-- 指定这个事务管理的数据源 -->
<!--
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
-->
<!-- 配置数据源 第二种使用通配符-->
<!-- location="jdbc.properties"指定加载的属性文件 -->
<context:property-placeholder location="jdbc.properties"/>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="${driverClassName}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
<!-- 连接池启动时的初始值 -->
<property name="initialSize" value="${initialSize}"/>
<!-- 连接池的最大值 -->
<property name="maxActive" value="${maxActive}"/>
<!-- 最大空闲值.当经过一个高峰时间后,连接池可以慢慢将已经用不到的连接慢慢释放一部分,一直减少到maxIdle为止 -->
<property name="maxIdle" value="${maxIdle}"/>
<!-- 最小空闲值.当空闲的连接数少于阀值时,连接池就会预申请去一些连接,以免洪峰来时来不及申请 -->
<property name="minIdle" value="${minIdle}"/>
</bean>
</beans>
然后编写jdbc.properties属性文件
driverClassName=org.gjt.mm.mysql.Driver
url=jdbc\:mysql\://localhost\:3306/student?useUnicode\=true&characterEncoding\=UTF-8
username=root
password=liyong
initialSize=1
maxActive=500
maxIdle=2
minIdle=1
<!-- 使用xml来 配置事务 -->:
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<aop:config>
<aop:pointcut id="transactionPointcut" expression="execution(* com.liyong.PersonService..*.*(..))"/>
<!-- 当拦截到方法后发出通知 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
</aop:config>
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<!-- 以下是拦截到的方法的事务配置 get*表示也get开头都是NOT_SUPPORTED不支持事务-->
<tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
<!-- 以下表示其它的方法也默认事务 -->
<tx:method name="*"/>
</tx:attributes>
</tx:advice>
- SpringJDBC.zip (12.4 KB)
- 下载次数: 7
发表评论
-
Spring 5 中文解析之核心篇-IoC容器
2020-08-27 11:23 442关于本书 本书 本书编写主要目的在于翻 ... -
Spring Boot Profile使用
2018-06-26 19:06 608Spring Boot使用@Profile注解可以实现不同 ... -
Spring事务配置的五种方式和spring里面事务的传播属性和事务隔离级别
2016-06-22 09:36 708Spring事务配置的五种方式 前段时间对Sprin ... -
Spring中@Autowired注解、@Resource注解的区别
2016-06-13 22:25 780Spring不但支持自己定义的@Autowired注解, ... -
Spring实现AOP的4种方式
2016-06-13 21:41 991先了解AOP的相关术语:1.通知(Advice):通知定义了 ... -
SpringMvc HttpClient上传参数
2016-05-04 21:58 3030SpringMVC代码示例如下: @RequestM ... -
重庆APP开发 重庆Android 重庆Ios 爬虫科技 重庆爬虫科技
2014-10-06 12:03 9<!--[if gte mso 9]><x ... -
spring中的事务学习
2012-05-11 09:11 1173/* * spring默认情况下会对unchecked会进行事 ... -
基于基于XML配置方式声明切面
2012-05-11 09:11 1531知识点: 【 //普通的java 类 public clas ... -
基于注解方式声明切面(AOP)
2012-05-10 10:55 1678基础知识: 【 首先启动对@AspectJ注解的支持(蓝色部 ... -
使用Spring进行面向切面(AOP)编程
2012-05-10 10:55 1168基础知识: 【 要进行AOP编程,首先我们要在spring的配 ... -
AOP中的概念
2012-05-10 10:55 972基础知识 【 Aspect(切面):指横切性关注点的抽象即为切 ... -
使用CGLIB生成代理
2012-05-10 10:55 1446知识点 【 使用前提条件: 【 /* * 如果这 ... -
JDK动态代理
2012-05-10 10:55 1253知识点 【 public class JDKProxy imp ... -
通过在classpath自动扫描方式把组件纳入spring容器中管理
2012-05-09 09:39 1420知识点 : 【 前面的例子我们都是使用XML的bean定义来 ... -
依赖注入--手工装配
2012-05-09 09:39 1210知识点: 【 手工装配依赖对象,在这种方式中又有两种编程方式 ... -
集合类型的装配
2012-05-09 09:39 1103知识点: 【 第一:设置集合属性 public class ... -
bean的生命周期
2012-05-05 22:41 0bean的生命周期: 如下配置: <bean id=& ... -
bean的生命周期
2012-05-09 09:39 1109bean的生命周期: 如下配置: <bean id=& ... -
注入依赖对象
2012-05-08 12:06 1004知识点: 【 基本类型 ...
相关推荐
SSM(Spring MVC + Spring + MyBatis)是Java Web开发中常见的三层架构组合,它将Spring MVC作为表现层框架,Spring作为业务层容器,MyBatis作为数据访问层框架。下面将详细介绍这三个组件以及它们如何协同工作。 *...
SpringMVC、Spring和JDBC是Java Web开发中常用的三个技术框架,它们组合在一起形成了SSM(Spring MVC、Spring、MyBatis)架构的一种变体。在这个项目中,"SpringMVC+Spring+JDBC环境"指的是利用这些技术构建一个完整...
Spring MVC、Spring和Mybatis是Java开发中非常流行的三大开源框架,它们的组合,通常被称为“SSM”框架。SSM框架的使用可以极大地提高Web应用的开发效率,通过合理的解耦,使得各组件能够更好地协同工作。接下来,...
在Java开发领域,Spring、SpringMVC和MyBatis框架的组合,简称SSM,是构建Web应用程序的常用技术栈。IntelliJ IDEA作为一款强大的Java集成开发环境,提供了便捷的工具来搭建这样的项目。以下是详细步骤: 1. **安装...
本篇文章将深入探讨如何使用Maven作为构建工具,在Eclipse环境中搭建一个整合了Spring、Spring MVC和Hibernate的项目。 首先,让我们了解Maven。Maven是Apache开发的一款项目管理和综合工具,它通过一个项目对象...
总结来说,Spring+WebWork+iBatis的组合为Java Web开发提供了一个强大且灵活的框架,能够帮助开发者快速构建高质量的应用程序。通过深入理解各个框架的功能和配置,我们可以更好地利用这些工具来满足项目需求。
SSM框架,即Spring、SpringMVC和Mybatis的组合,是Java开发Web应用时常见的技术栈。这个基础环境搭建工程提供了完整的配置和测试用例,帮助开发者快速启动基于SSM的项目。以下是对这个工程的详细解读: 1. **Spring...
SSM框架是Java开发中常用的一种组合,由Maven、Spring、Spring MVC和MyBatis四个组件构成,加上MySQL作为数据库支持,形成了一个强大的企业级应用开发基础。下面将详细介绍这些组件及其在搭建环境中扮演的角色。 1....
### Struts2+Spring2+Hibernate3.1开发环境搭建详解 #### 一、概述 在Java Web开发领域,Struts2、Spring2与Hibernate3.1是非常经典的组合,它们分别负责表现层、业务逻辑层以及数据访问层,能够帮助开发者快速...
在IT行业中,SSH框架是Java Web开发中常用的三大框架组合,包括SpringMVC、Spring和Hibernate。本教程将详细介绍如何一步步搭建一个基于SSH的Web应用环境,并提供了解决常见问题的说明文档。 首先,让我们从...
SSM框架,即Spring、SpringMVC和MyBatis的集成,是Java开发中常见的Web应用程序框架组合。这个框架集合提供了完整的后端解决方案,涵盖了依赖注入(DI)、面向切面编程(AOP)、模型视图控制器(MVC)以及持久层操作...
这是一个经典的Java后端开发组合,常用于构建高效、可扩展的企业级应用。首先,让我们逐一了解这三个组件的核心功能。 Spring框架是Java企业级应用的事实标准,它提供了依赖注入(Dependency Injection,DI)和面向...
Struts2、Spring和MyBatis是Java Web开发中经典的三大框架,它们组合起来可以构建出高效、可维护的Web应用程序。以下是对这三个框架及其整合的详细解释。 **Struts2框架** Struts2是一个基于MVC(Model-View-...
### Struts+Spring+Hibernate框架搭建 #### 1. SSH整合理念 在现代软件开发中,特别是Java Web应用开发领域,采用多个框架协同工作已成为一种常见的做法。这种做法旨在通过不同框架的优势互补来构建高性能、高灵活...
这是一个广泛应用于企业级开发的组合,因为它能够提供灵活的控制层、强大的持久层支持以及安全的权限管理。 **Spring框架**是Java企业级应用的核心框架,它提供了依赖注入(Dependency Injection, DI)和面向切面...
SSH(Struts2+Spring2+Hibernate3.1)是一种经典的Java Web开发框架组合,用于构建高效、模块化的应用程序。以下是关于如何搭建SSH开发环境的详细步骤: 1. **Struts2配置**: - **添加依赖库**:在项目中引入...
Spring+SpringMVC+Mybatis框架是Java开发中常见的企业级应用架构组合,因其灵活性、易用性和强大的功能而备受开发者喜爱。这三个框架的结合,为Web应用提供了模型-视图-控制器(MVC)的设计模式,实现了业务逻辑、...
在IT行业中,构建一个高效的Java应用开发环境是至关重要的,而"Maven+Spring+MyBatis+MySQL+JUnit"的组合则是一个常见的选择。这个框架集合涵盖了项目构建、依赖管理、业务逻辑处理、数据库交互以及单元测试等多个...
在IT行业中,构建Web应用程序是常见的任务之一,而Spring、SpringMVC和Mybatis这三大框架的组合(SSM框架)被广泛应用于Java Web开发。本文将深入探讨如何使用这三个框架来搭建一个简单的项目。 首先,Spring框架是...