spring初级——基于XML和注解的JDBC操作

最新推荐文章于 2023-04-05 21:50:45 发布

屎壳郎推球球

最新推荐文章于 2023-04-05 21:50:45 发布

阅读量266

点赞数

分类专栏： web框架

本文链接：https://blog.csdn.net/weixin_42304484/article/details/108413867

版权

web框架专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1.基于XML配置的JDB操作数据库

使用c3p0作为数据源，使用dbUtils工具类操作数据库

1.1配置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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!--配置操作数据库的数据源-->
   <bean id = "dataSource" class = "com.mchange.v2.c3p0.ComboPooledDataSource">
       <!--设置驱动名-->
       <property name="driverClass" value="com.mysql.jdbc.Driver"/>
       <!--设置url-->
       <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mydb"/>
       <!--设置数据库用户名-->
        <property name="user" value="root"/>
       <!--设置密码-->
       <property name="password" value="123"/>
   </bean>

    <!--配置dbUtil-->
    <bean id = "queryRunner" class = "org.apache.commons.dbutils.QueryRunner">
        <!--注入数据源通过构造器注入-->
       <constructor-arg ref="dataSource"></constructor-arg>
    </bean>
    <!--配置UserDao-->
    <bean name="userDao" class="com.wy.dao.UserDao">
        <!--name属性需要和set方法传入的参数名一致-->
        <property name="queryRunner" ref="queryRunner"/>
    </bean>
</beans>

1.2操作的实体类

package com.wy.bean;
public class User {
    private int id;
    private String username;
    private String sex;

    //用于封装数据
    public User(String username, String sex) {
        this.username = username;
        this.sex = sex;
    }
	
    //dbUtil的query方法的BeanHandler<T>()参数和BeanListHandler<T>()需要一个空参构造函数，如果没有会导致     //反射创建实体类失败。
    public User() {
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

1.3负责CRUD的UserDao

package com.wy.dao;
import com.wy.bean.User;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

/**
 * 操作数据库
 */
public class UserDao {
    private QueryRunner queryRunner;

    //引用数据类型的注入需要提供set方法
    public void setQueryRunner(QueryRunner queryRunner) {
        this.queryRunner = queryRunner;
    }

    /**
     * 保存
     *
     * @param user
     */
    public void save(User user) throws SQLException {
        queryRunner.update("insert into user(username,sex) values(?,?)", user.getUsername(), 			user.getSex());
    }

    /**
     * 修改
     *
     * @param user
     * @return
     */
    public int update(User user) throws SQLException {
        return queryRunner.update("update user set username = ? , sex = ? where id = ?", user.getUsername(), user.getSex(), user.getId());
    }

    /**
     * 根据id删除
     *
     * @param id
     * @return
     */
    public int delete(int id) throws SQLException {
        return queryRunner.update("delete from user where id = ?", id);
    }

    /**
     * 根据id查询
     *坑：BeanHandler通过反射创建的时候如果bean里有代参构造函数时将无法创建
     * bean对象，必须提供一个无参的构造函数
     * @param id
     * @return
     */
    public User findById(int id) throws SQLException {
        return queryRunner.query("select * from user where id = ?",new BeanHandler<User>(User.class), id);
    }

    public List<User> findAll() throws SQLException {
        return queryRunner.query("select * from user",new BeanListHandler<User>(User.class));
    }
}

1.4 测试类

package com.wy;
import com.wy.bean.User;
import com.wy.dao.UserDao;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.sql.SQLException;
import java.util.Iterator;
public class TestCRUD {
    private ClassPathXmlApplicationContext ctx;
    @Before
    public void init(){
        //加载spring配置文件初始化spring容器
        ctx = new ClassPathXmlApplicationContext("bean.xml");
    }

    @Test
    public void fun() throws SQLException {
        //根据id获取UserDao
        UserDao userDao = (UserDao) ctx.getBean("userDao");

        //调用UserDao进行数据的操纵
        User u = userDao.findById(1);
        System.out.println(u);
        userDao.delete(3);
//        添加数据
        userDao.save(new User("魏海浩","男"));

//        查所有
        Iterator<User> iterator = userDao.findAll().iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

2、注解方式

2.1 常用的注解

注入时常用的注解（前提条件是Spring容器中已经有了这个被注入的bean）

@Componet、@Service、@reposotory、@Controller

其中，@Service、@reposotory、@Controller@Componet功能相同，只不过为了MVC开发，设计了三个注解。

*以上四个注解只能注入bean类型的数据，无法注入String和基本数据类型。

@Value注解可以为javabean中的属性绑定数据，主要作用为使用springEL表达式从外部配置文件读取配置信息，绑定到属性上

 	/**
     * 将JDBC的配置信息抽取出来，使用spring的Value注解搭配spring的el表达式绑定数据
     */
    @Value("${jdbc.driver}")
    private String driver;

    @Value("${jdbc.url}")
    private String url;

    @Value("${jdbc.user}")
    private String user;

    @Value("${jdbc.password}")
    private String password;

jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/mydb
jdbc.user = root
jdbc.password = 123

2.2使用配置类代替xml配置文件

可以使用Java配置类的方式进行spring的配置，需要在配置类上添加@Configuration注解，其次还需要添加

@ComponmentScan(basePackage ={})用于开启spring的注解扫描功能，此外还可以使用多配置文件的方式，即主配置文件管理多个子配置文件，需要在主配置类上添加@Import注解引入其他的子配置类。

主配置类

package com.wy.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.PropertySource;

/**
 * 使用配置类代替配置文件
 * 1、Configuration标注一个类为配置类
 * 2、ComponentScan 创建容器时扫描的包路径(注意是类路径，如果类上未标注解将扫描不到)
 *        2.1、如果使用AnnotationConfigApplicationContext(SpringConfiguration.class),加载
 *             配置类，可以不需要在类上标注Configuration(不推荐)
 *        2.2、可以使用@Import(JdbcConfig.class)注解，将其他注解导入到主配置类中管理
 *
 *
 * 3、当使用注解配置方法时，如果方法有参数，
 * spring将会从容器中查找有无可用的对象。
 * 方式和autowire一样，自动按照类型注入
 *4、@PropertySource({"classpath:JdbcConfig.properties"})加载类路径下的配置文件
 */
//将它作为主配置类
@Configuration
@ComponentScan(basePackages = {"com.wy"})
@Import(JdbcConfig.class)
@PropertySource({"classpath:JdbcConfig.properties"})
public class SpringConfiguration {


}

子配置类

package com.wy.config;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;
import java.beans.PropertyVetoException;
import java.sql.SQLException;

public class JdbcConfig {
    /**
     * 将JDBC的配置信息抽取出来，使用spring的Value注解搭配spring的el表达式绑定数据
     */
    @Value("${jdbc.driver}")
    private String driver;

    @Value("${jdbc.url}")
    private String url;

    @Value("${jdbc.user}")
    private String user;

    @Value("${jdbc.password}")
    private String password;

    /**
     * Bean注解默认在容器中生成的bean是单例的
     * 可以搭配@Scope("prototype")将bean变为多例
     * @return
     * @throws PropertyVetoException
     * @throws SQLException
     */
    @Bean("dataSource")
    public DataSource getDataSource() throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass(driver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(user);
        dataSource.setPassword(password);
        return dataSource;
    }
    @Bean("queryRunner")
    public QueryRunner getRunner(DataSource dataSource){
        return new QueryRunner(dataSource);
    }
}

配置类中可以使用@Bean注解，来声名该bean由spring容器管理；当使用@Bean注解配置方法时，如果方法有参数，spring将会从容器中查找有无可用的对象，如果有将会按照类型将查找到的bean与参数进行绑定，（如上代码块中的getQuerry方法需要一个DataSource类型的参数，则spring会将上文中的DataSource与其绑定），方式和autowire一样，自动按照类型注入。

2.3基于注解的JDBC操作数据库

2.3.1主配置类，与上相同

2.3.2子配置类，与上相同

2.3.3操作的实体类

package com.wy.bean;
//如果不提供set方法，dbUtils将无法为我们封装从数据库查到的数据
public class User {
    private int id;
    private String username;
    private String sex;

    //用于封装数据
    public User(String username, String sex) {
        this.username = username;
        this.sex = sex;
    }

    public User() {
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
}

2.3.4负责CRUD的UserDao

package com.wy.dao;
import com.wy.bean.User;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import java.sql.SQLException;
import java.util.List;

@Repository
public class UserDao {
    @Autowired
    private QueryRunner queryRunner;

    /**
     * 查所有
     * @return
     * @throws SQLException
     */
    public List<User>findAll() throws SQLException {
        return queryRunner.query("select * from user",new BeanListHandler<User>(User.class));
    }

    /**
     * 根据id查
     * @param id
     * @return
     */
    public User findById(int id) throws SQLException {
        return queryRunner.query("select * from user where id = ?",new BeanHandler<User>(User.class),id);
    }


    /**
     * 保存
     * @param user
     * @return
     */
    public int save(User user) throws SQLException {
        return queryRunner.update("inser into user(username,sex) values(?,?)",user.getUsername(),user.getSex());
    }

    /**
     * 修改
     * @param user
     * @return
     */
    public int update(User user) throws SQLException {
        return queryRunner.update("update user set username = ?,sex = ?",user.getUsername(),user.getSex());
    }

    /**
     * 删除
     * @param id
     * @return
     */
    public int delete(int id) throws SQLException {
        return queryRunner.update("delete from user where id = ?",id);
    }
}

2.3.5测试类

package com.wy;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import com.wy.bean.User;
import com.wy.config.SpringConfiguration;
import com.wy.dao.UserDao;
import org.apache.commons.dbutils.QueryRunner;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import java.sql.SQLException;
import java.util.Iterator;

public class test {
    AnnotationConfigApplicationContext ctx;

    //初始化spring容器
    @Before
    public void before(){
        ctx = new AnnotationConfigApplicationContext(SpringConfiguration.class);
    }


    @Test
    public void fun1() throws SQLException {
        UserDao userDao = (UserDao) ctx.getBean("userDao");
		//查所有
        Iterator<User> iterator = userDao.findAll().iterator();
        while(iterator.hasNext())
            System.out.println(iterator.next());

        //根据id查
        System.out.println(userDao.findById(4));

    }
}