Spring-JDBC实践

Spring-JDBC完成Contact的CRUD。

两点注意：

　　1.log4j.properties文件不能少

　　2.注意导入的包之间的依赖关系以及版本要求。

项目结构：

主要文件：

建表脚本：

CREATE TABLE contact (
  id int(10) unsigned NOT NULL auto_increment,
  name varchar(45) NOT NULL,
  address varchar(45) default NULL,
  gender char(1) default ‘M‘,
  dob datetime default NULL,
  email varchar(45) default NULL,
  mobile varchar(15) default NULL,
  phone varchar(15) default NULL,
  PRIMARY KEY  (id)
) ENGINE=InnoDB AUTO_INCREMENT=20 DEFAULT CHARSET=utf8

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>MarkDemo</groupId>
    <artifactId>SpringDAO</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <build />

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.1.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>4.1.1.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-dao</artifactId>
            <version>2.0.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.1.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.33</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.0.2</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.1.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5-pre9</version>
        </dependency>

    </dependencies>

</project>

properties文件

jdbc.properties

------------------------------------
mysql.driverClassName=com.mysql.jdbc.Driver
mysql.url=jdbc:mysql://localhost:3306/test
mysql.username=root
mysql.password=111222

log4j.properties

# Configure logging for testing: optionally with log file
log4j.rootLogger=WARN, stdout

# log4j.rootLogger=WARN, stdout, logfile

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n

log4j.appender.logfile=org.apache.log4j.FileAppender
log4j.appender.logfile.File=target/spring.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

spring-dao.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:context="http://www.springframework.org/schema/context"
    xmlns:p="http://www.springframework.org/schema/p" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
               http://www.springframework.org/schema/context
               http://www.springframework.org/schema/context/spring-context-4.1.xsd
               http://www.springframework.org/schema/tx
            http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
            http://www.springframework.org/schema/mvc
            http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd">

    <!-- not  property-placeholder -->
    <!-- <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"
        p:driverClassName="com.mysql.jdbc.Driver" p:url="jdbc:mysql://localhost:3306/test"
        p:username="root" p:password="111222" /> -->

    <context:property-placeholder location="classpath:jdbc.properties" />
    <!-- <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"
        p:driverClassName="${mysql.driverClassName}" p:url="${mysql.url}" p:username="${mysql.username}"
        p:password="${mysql.password}" />. -->

    <!-- c3p0 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${mysql.username}" />
        <property name="password" value="${mysql.password}" />
        <property name="driverClass" value="${mysql.driverClassName}" />
        <property name="jdbcUrl" value="${mysql.url}" />
        <property name="maxPoolSize" value="20" />
        <property name="minPoolSize" value="2" />
        <property name="initialPoolSize" value="2"/>
        <property name="maxIdleTime" value="60"/>
    </bean>

</beans>

Contact.java
import java.sql.Date;

public class Contact {
    private Integer id;
    private String name;
    private String address;
    private String gender;
    private Date dob;
    private String email;
    private String mobile;
    private String phone;

    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 getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Date getDob() {
        return dob;
    }

    public void setDob(Date dob) {
        this.dob = dob;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getMobile() {
        return mobile;
    }

    public void setMobile(String mobile) {
        this.mobile = mobile;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

}
ContactRowMapper.java
--ContactRowMapper.java
import java.sql.ResultSet;
import java.sql.SQLException;

import org.springframework.jdbc.core.RowMapper;

public class ContactRowMapper implements RowMapper<Contact> {

    public Contact mapRow(ResultSet arg0, int arg1) throws SQLException {

        Contact contact = new Contact();
        contact.setId(arg0.getInt("id"));
        contact.setName(arg0.getString("name"));
        contact.setAddress(arg0.getString("address"));
        contact.setGender(arg0.getString("gender"));
        contact.setDob(arg0.getDate("dob"));
        contact.setEmail(arg0.getString("email"));
        contact.setMobile(arg0.getString("mobile"));
        contact.setPhone(arg0.getString("phone"));

        return contact;
    }

}
ContactsDAO.java
--ContactsDAO.java
import java.util.List;

public interface ContactsDAO {

    Contact getContact(Integer id);

    Integer Create(Contact contact);

    Boolean Update(Contact contact);

    Boolean Delete(Integer id);

    List<Contact> Search(String name);

    List<Contact> getAllContacts();

}
ContactsDAOImpl.java
--ContactsDAOImpl.java
import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.List;
import org.springframework.jdbc.core.PreparedStatementCreator;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;

public class ContactsDAOImpl extends JdbcDaoSupport implements ContactsDAO {

    public Contact getContact(Integer id) {
        Contact contact = this.getJdbcTemplate().queryForObject("select * from contact where id=?", new Object[] { id }, new ContactRowMapper());

        return contact;
    }

    /**
     * Add a new contact to database, and return the id.
     *
     * @author Mark
     * @param Object
     *            of Contact
     * @return [Integer] Auto Increment Key
     * @see http://blog.chinaunix.net/uid-1848701-id-2825787.html
     * */
    public Integer Create(Contact contact) {
        final Contact contact2;
        contact2 = contact;

        if (contact.getId() != null)
            throw new RuntimeException("contact with id " + contact.getId() + " is already existed.");

//        Object[] params = new Object[] { contact.getName(), contact.getAddress(), contact.getGender(), contact.getDob(), contact.getEmail(),
//                contact.getMobile(), contact.getPhone() };
//        int id = this.getJdbcTemplate().update("insert into contact(name, address, gender, dob, email, mobile, phone) values(?,?,?,?,?,?,?);", params);

        final String strSql = "insert into contact(name, address, gender, dob, email, mobile, phone) values(?,?,?,?,?,?,?);";
        KeyHolder keyHolder = new GeneratedKeyHolder();
        int id1 = this.getJdbcTemplate().update(new PreparedStatementCreator() {
            public PreparedStatement createPreparedStatement(Connection conn) throws SQLException {
                int i = 0;
                java.sql.PreparedStatement ps = conn.prepareStatement(strSql, new String[] { "object_id" });
                ps = conn.prepareStatement(strSql, Statement.RETURN_GENERATED_KEYS);
                ps.setString(++i, contact2.getName());
                ps.setString(++i, contact2.getAddress());
                ps.setString(++i, contact2.getGender());
                ps.setDate(++i, (Date) contact2.getDob());
                ps.setString(++i, contact2.getEmail());
                ps.setString(++i, contact2.getMobile());
                ps.setString(++i, contact2.getPhone());

                return ps;
            }
        }, keyHolder);

        return keyHolder.getKey().intValue();

    }

    public Boolean Update(Contact contact) {
        Object[] param = new Object[] { contact.getName(), contact.getAddress(), contact.getGender(), contact.getDob(), contact.getEmail(),
                contact.getMobile(), contact.getPhone(), contact.getId() };
        int count = this.getJdbcTemplate().update("update contact set name=?, address=?, gender=?, dob=?, email=?, mobile=?, phone=? where id=?", param);

        return count > 0 ? Boolean.TRUE : Boolean.FALSE;
    }

    public Boolean Delete(Integer id) {
        int count = this.getJdbcTemplate().update("delete from contact where id=?;", new Object[] { id });

        return count > 0 ? Boolean.TRUE : Boolean.FALSE;
    }

    public List<Contact> Search(String name) {
        List<Contact> contactList = this.getJdbcTemplate().query("select * from contact where name like %?%;", new Object[] { name }, new ContactRowMapper());

        return contactList;
    }

    public List<Contact> getAllContacts() {
        List<Contact> contactList = this.getJdbcTemplate().query("select * from contact;", new ContactRowMapper());

        return contactList;
    }

}
ContactsDAOTestClient.java
--ContactsDAOTestClient.java
import org.springframework.context.ApplicationContext;
import java.sql.Date;
import javax.sql.DataSource;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ContactsDAOTestClient {

    @SuppressWarnings("deprecation")
    public static void main(String[] args) {
        System.out.println("hello jdbc, see you tomorrow.");
        ApplicationContext applicationContext = null;

        try {
            applicationContext = new ClassPathXmlApplicationContext("classpath:spring-dao.xml");
        } catch (Exception e) {
            e.printStackTrace();
        }

        DataSource dataSource = (DataSource) applicationContext.getBean("dataSource");
        ContactsDAOImpl contactDao = new ContactsDAOImpl();
        contactDao.setDataSource(dataSource);

        Contact contact = new Contact();
        contact.setName("MARK");
        contact.setAddress("WITH HOUSE");
        contact.setGender("M");
        contact.setDob(new Date(1986,11,07));
        contact.setEmail("[email protected]");
        contact.setMobile("13028865078");
        contact.setPhone("0755-06326545"); 

        //add a new contact
        int id=contactDao.Create(contact);

        //get the inserted contact
        contactDao.getContact(id);

        System.out.println(id);

    }
}
时间： 2024-08-13 10:05:46

Spring-JDBC实践的相关文章

开涛spring3(7.5) - 对JDBC的支持 之 7.5 集成Spring JDBC及最佳实践

7.5 集成Spring JDBC及最佳实践 大多数情况下Spring JDBC都是与IOC容器一起使用.通过配置方式使用Spring JDBC. 而且大部分时间都是使用JdbcTemplate类(或SimpleJdbcTemplate和NamedParameterJdbcTemplate)进行开发,即可能80%时间使用JdbcTemplate类,而只有20%时间使用其他类开发,符合80/20法则.   Spring JDBC通过实现DaoSupport来支持一致的数据库访问. Spring J

Spring MVC 实践 - Base

Spring MVC 实践 标签 : Java与Web Spring Web MVC Spring-Web-MVC是一种基于请求驱动的轻量级Web-MVC设计模式框架, Spring MVC使用MVC架构思想, 对Web层进行职责解耦,使用请求-响应模型将数据.业务与视图进行分离, 简化开发. MVC MVC(模型-视图-控制器)是一个以设计界面应用程序为基础的架构模式,通过分离模型-视图-控制器在应用中的角色将业务逻辑从界面中解耦: 模型负责封装应用数据和业务逻辑; 视图仅负责展示数据; 控制

一个spring jdbc实例

一.使用示例 (1)springJdbcContext.xml Java代码   <?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:context

Spring JDBC 框架中, 绑定 SQL 参数的另一种选择：具名参数(named parameter)

使用spring的jdbcTemplate-----使用具名参数 在JDBC用法中,SQL参数是用占位符?表示,并且受到位置的限制,定位参数的问题在于,一旦参数的位置发生变化,必须改变参数的绑定,在Spring JDBC中,绑定SQL参数的另一种选择是使用具名参数,SQL具名参数是按照名称绑定,而不是位置绑定. 什么是具名参数? 具名参数: SQL 按名称(以冒号开头)而不是按位置进行指定. 具名参数更易于维护, 也提升了可读性. 具名参数由框架类在运行时用占位符取代 具名参数只在 NamedP

Unit06： Spring对JDBC的 整合支持 、 Spring+JDBC Template、Spring异常处理

Unit06: Spring对JDBC的 整合支持 . Spring+JDBC Template .Spring异常处理 1. springmvc提供的异常处理机制 我们可以将异常抛给spring框架,让spring来帮我们处理异常. (1)使用简单异常处理器 step1. 配置简单异常处理器. step2. 添加对应的异常处理页面. 注:该方式只适合处理简单异常的处理,如果要对异常做复杂处理,比如 记录日志等,则不合适了. (2)使用@ExceptionHandler注解 step1. 在处理

Spring JDBC详解

<Spring JDBC详解> 本文旨在讲述Spring JDBC模块的用法.Spring JDBC模块是Spring框架的基础模块之一. 作者:chszs,转载需注明.博客主页:http://blog.csdn.net/chszs 一.概述 在Spring JDBC模块中,所有的类可以被分到四个单独的包:1)core即核心包,它包含了JDBC的核心功能.此包内有很多重要的类,包括:JdbcTemplate类.SimpleJdbcInsert类,SimpleJdbcCall类,以及NamedP

Spring JDBC入门

Spring将替我们完成所有使用JDBC API进行开发的单调乏味的.底层细节处理工作. 操作JDBC时Spring可以帮我们做这些事情: 定义数据库连接参数,打开数据库连接,处理异常,关闭数据库连接 我们仅需要关注: 声明SQL语句,处理每一次得到的结果 一个较为简单的例子与讲解 JdbcTemplate类 JdbcTemplate是core包的核心类.它替我们完成了资源的创建以及释放工作,从而简化了我们对JDBC的使用.它还可以帮助我们避免一些常见的错误,比如忘记关闭数据库连接.JdbcTe

Spring JDBC实现查询

1 db.properties 1 jdbc.user=root 2 jdbc.password=920614 3 jdbc.driverClass=com.mysql.jdbc.Driver 4 jdbc.jdbcUrl=jdbc:mysql:///spring?useUnicode=true&characterEncoding=utf-8 5 6 jdbc.initPoolSize=5 7 jdbc.maxPoolSize=10 2 applicationContext.xml 1 <?

Spring DAO vs Spring ORM vs Spring JDBC

Pat 的疑惑 最近关注于 Spring 提供的数据访问技术,对于 Spring 相关的这几个项目有何不同我不是太明白: Spring-DAO (http://docs.spring.io/spring/docs/2.0.8/reference/dao.html) Spring-ORM (http://docs.spring.io/spring/docs/3.0.x/spring-framework-reference/html/orm.html) Spring-JDBC (http://doc

Spring JDBC 访问数据库

Spring JDBC是Spring所提供的持久层技术,它以一种更直接.更简单的方式使用JDBC API.在Spring JDBC里,用户仅需要做那些必不可杀的事儿,而将资源获取.Statement创建.异常处理.资源释放等繁杂的工作交给Spring. 虽然ORM的框架已经很成熟,但是JDBC灵活直接的特性依旧让它有自己的用武之地. 本节的主要内容:使用JdbcTemplate模板类进行CRUD数据操作.BLOB和CLOB类型数据的操作,支持命名参数绑定NamedParameterJdbcTem