Eine kurze Einführung in JdbcTemplate

1. Über JdbcTemplate

JdbcTemplate ist die grundlegendste Spring-JDBC-Vorlage. Diese Vorlage unterstützt einfache JDBC-Datenbankzugriffsfunktionen und -abfragen basierend auf Indexparametern.

Spring-Datenzugriffsvorlage: Während des Datenbankbetriebs gibt es einen großen Teil der wiederholten Arbeit, wie z. B. Transaktionssteuerung, Ressourcenverwaltung, Ausnahmebehandlung usw. Die Vorlagenklasse von Spring verarbeitet diese festen Teile. Gleichzeitig wird der anwendungsbezogene Datenzugriff in der Callback-Implementierung abgewickelt, einschließlich Anweisungen, Bindungsparameter und Sortierergebnisse. Auf diese Weise müssen wir uns nur um unsere eigene Datenzugriffslogik kümmern.

Das JDBC-Framework von Spring übernimmt die Arbeit der Ressourcenverwaltung und Ausnahmebehandlung und vereinfacht so den JDBC-Code. Wir müssen nur den notwendigen Code schreiben, um Daten aus dem zu lesen und zu schreiben Datenbank und alles wird gut.

2. Spring JdbcTemplate-Instanz

Unser Lernziel ist es, eine Demo zur Implementierung von CRUD-Operationen für die Kategorie zu schreiben.

1. Erstellen Sie die Tabelle

MySQL, um einen neuen Datenbankspeicher zu erstellen, und führen Sie dann die folgende SQL aus:

create table Category (
Id int not null,
Name varchar(80) null,constraint pk_category primary key (Id)
);INSERT INTO category(id,Name) VALUES (1,'女装');INSERT INTO category(id,Name) VALUES (2,'美妆');INSERT INTO category(id,Name) VALUES (3,'书籍');

db_store.sql

2. Die IDE, die ich verwende, ist IdeaIU. Ich erstelle das Projekt über Maven und konfiguriere Spring über XML. Die fertige Codestruktur lautet:

3. Erstellen Sie die Entitätsklasse Kategorie

public class Category{
    private int cateId;

    private String cateName;

    public int getCateId() {
        return cateId;
    }

    public void setCateId(int cateId) {
        this.cateId = cateId;
    }

    public String getCateName() {
        return cateName;
    }

    public void setCateName(String cateName) {
        this.cateName = cateName;
    }

    @Override
    public String toString() {
        return "id="+cateId+" name="+cateName;
    }
}

　

4 .Ändern Sie pom.xml und führen Sie relevante Abhängigkeiten ein.

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

        <!-- Mysql数据库链接jar包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.21</version>
            <scope>runtime</scope>
        </dependency>
    </dependencies>

　

5. Konfigurieren Sie applicationContext.xml

Sie müssen dataSource als Datenquelle von jdbcTemplate konfigurieren. Konfigurieren Sie dann die CategoryDao-Bean und erstellen Sie das jdbcTemplate-Objekt. Die vollständige applicationContext.xml lautet wie folgt:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans ">
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/store"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    
    <bean id="categoryDao" class="CategoryDao">
        <constructor-arg ref="jdbcTemplate"></constructor-arg>
    </bean>
</beans>

　

6. Der Konstruktor der Datenzugriffsimplementierungsklasse CategoryDao

CategoryDao enthält den Parameter jdbcTemplate Anschließend wurden allgemeine Datenzugriffsvorgänge implementiert. Wie Sie sehen, müssen wir nur auf die spezifische SQL-Anweisung achten. Darüber hinaus wird die Lambda-Syntax in den Methoden getById() und getAll() verwendet.

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

/**
 * Created by 陈敬 on 2017/6/6.
 */
public class CategoryDao {
    private JdbcTemplate jdbcTemplate;

    public CategoryDao(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public int add(Category category) {
        String sql = "INSERT INTO category(id,name)VALUES(?,?)";
        return jdbcTemplate.update(sql, category.getCateId(), category.getCateName());
    }

    public int update(Category category) {
        String sql = "UPDATE Category SET Name=? WHERE Id=?";
        return jdbcTemplate.update(sql, category.getCateName(), category.getCateId());
    }

    public int delete(int id) {
        String sql = "DELETE FROM Category WHERE Id=?";
        return jdbcTemplate.update(sql, id);
    }

    public int count(){
        String sql="SELECT COUNT(0) FROM Category";
        return jdbcTemplate.queryForObject(sql,Integer.class);
    }

    public Category getById(int id) {
        String sql = "SELECT Id,Name FROM Category WHERE Id=?";
        return jdbcTemplate.queryForObject(sql, (ResultSet rs, int rowNumber) -> {
            Category category = new Category();
            category.setCateId(rs.getInt("Id"));
            category.setCateName(rs.getString("Name"));
            return category;
        }, id);
    }

    public List<Category> getAll(){
        String sql="SELECT Id,Name FROM Category";

        List<Category> result=jdbcTemplate.query(sql, (resultSet, i) -> {
            Category category = new Category();
            category.setCateId(resultSet.getInt("Id"));
            category.setCateName(resultSet.getString("Name"));
            return category;
        });

        return result;
    }
}

　

7. Test

@ContextConfiguration(locations = "classpath:applicationContext.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class testCategoryDao {
    @Autowired
    private CategoryDao categoryDao;

    @Test
    public void testAdd() {
        Category category = new Category();
        category.setCateId(4);
        category.setCateName("母婴");

        int result = categoryDao.add(category);
        System.out.println(result);
    }

    @Test
    public void testUpdate() {
        Category category = new Category();
        category.setCateId(4);
        category.setCateName("男装");

        int result = categoryDao.update(category);
        System.out.println(result);
    }


    @Test
    public void testGetById() {
        int id = 4;
        Category category = categoryDao.getById(id);
        System.out.println(category.toString());
    }

    @Test
    public void testGetAll() {
        List<Category> categories = categoryDao.getAll();
        for (Category item : categories) {
            System.out.println(item);
        }
    }

    @Test
    public void testCount() {
        int count = categoryDao.count();
        System.out.println(count);
    }

    @Test
    public void testDelete() {
        int id = 4;
        int result = categoryDao.delete(id);
        System.out.println(result);
    }
}

Das obige ist der detaillierte Inhalt vonEine kurze Einführung in JdbcTemplate. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!