SpringMVC JDBC

最新推荐文章于 2022-11-03 15:13:44 发布
最新推荐文章于 2022-11-03 15:13:44 发布
阅读量509 收藏
点赞数
分类专栏： 工作足迹
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013491262/article/details/49489721
版权

依赖jar
1、建立数据库

DROP TABLE IF EXISTS `TWORKERSINFO`;  
CREATE TABLE `TWORKERSINFO` (  
  `VC_id` int(11) NOT NULL AUTO_INCREMENT,  
  `VC_workername` varchar(20) NOT NULL,  
  `VC_sex` enum('F','M'),  
  `VC_salary` int(11) DEFAULT '0',  
  `VC_email`  varchar(30),  
  `VC_employedDates`  date,  
  `VC_department`  varchar(30),  
  PRIMARY KEY (`VC_id`)  
) ENGINE=MyISAM  DEFAULT CHARSET=utf8;

这里ENGINE=MyISAM 说明：
MyISAM:,它是基于传统的ISAM类型,ISAM是Indexed Sequential Access Method (有索引的 顺序访问方法) 的缩写,它是存储记录和文件的标准方法.与其他存储引擎比较,MyISAM具有检查和修复表格的大多数工具. MyISAM表格可以被压缩,而且它们支持全文搜索.它们不是事务安全的,而且也不支持外键。如果事物回滚将造成不完全回滚，不具有原子性。如果执行大量 的SELECT，MyISAM是更好的选择。

这里写图片描述
2、注解

package com.liyang.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 
 * 标识表
 *
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.TYPE})
public @interface Table {

       public  abstract String name() default "" ;

}

package com.liyang.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * 
 * 标识主键
 *
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.FIELD})
public @interface Primary{

}

package com.liyang.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 
 * 标识字段
 *
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.FIELD})
public @interface Column {

       public abstract  String  name()  default "" ;

}

3、数据库

package com.liyang.database;

public interface DBRunner {


       public abstract  void execute(String sql , Object... values) throws Exception ;

       public abstract  void insert(Object obj)  throws Exception ;


}

package com.liyang.database;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.math.BigDecimal;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.liyang.annotation.Column;
import com.liyang.annotation.Table;



public abstract class AbstractDBRunner implements DBRunner{


       @Override
       public void insert(Object obj) throws Exception{

              if(obj == null) 
                   throw new Exception("插入数据为空！") ;

              Class<?> clazz = obj.getClass() ;

              Table table = clazz.getAnnotation(Table.class) ;
              if(table == null)
                   throw  new Exception("插入数据所指向的表为空！") ;

              Field[] fields = clazz.getDeclaredFields() ;
              if(fields.length == 0)
                   throw  new Exception("插入数据所指向的列为空！") ;

              String  tableName = table.name() ;

              List<Object> lisobj = new ArrayList<Object>() ;
              List<String> liscolumns = new ArrayList<String>() ;

              try{

                    for(Field field : fields){
                          field.setAccessible(true) ;
                          Object value = field.get(obj) ;
                          if(value == null) continue ; 
                          Column column = field.getAnnotation(Column.class) ;

                          lisobj.add(value) ;
                          liscolumns.add(column.name()) ;
                    }

              }
              catch(Exception e){
                   throw  new Exception("转换出错") ; 
              }

              if(liscolumns.size() == 0) return ;

              String  sqlStr = "insert into " + tableName + "(" ;
              sqlStr += liscolumns.get(0) ;
              for(int i = 1 , n = liscolumns.size() ; i < n ;  i++){
                      sqlStr += "," + liscolumns.get(i) ;
              }
              sqlStr += ") values( ? " ;
              for(int i = 1 , n = lisobj.size() ; i < n ; i++){
                   sqlStr += ",?" ;
              }
              sqlStr += ")" ;

              execute(sqlStr, lisobj.toArray()) ;

       }


        @SuppressWarnings("unchecked")
        protected <T> T extract(Class<T> clazz, ResultSet rs) {

            T t = null;
            try {
                ResultSetMetaData x = rs.getMetaData();
                int columnCount = x.getColumnCount();
                if (columnCount == 0)
                    return null;

                Table entity = clazz.getAnnotation(Table.class);

                if (entity == null) {
                    if (clazz.equals(Map.class)) {
                        Map<String, Object> map = new HashMap<String, Object>();
                        for (int i = 1; i <= columnCount; i++) {
                            map.put(x.getColumnLabel(i), rs.getObject(i));
                        }
                        return (T) map;
                    } else if (clazz.equals(List.class)) {
                        List<Object> list = new ArrayList<Object>();
                        for (int i = 1; i <= columnCount; i++) {
                            list.add(rs.getObject(i));
                        }
                        return (T) list;
                    } else if (clazz.equals(Object[].class)) {
                        Object[] os = new Object[columnCount];
                        for (int i = 1; i <= columnCount; i++) {
                            os[i - 1] = rs.getObject(i);
                        }
                        return (T) os;
                    } else if (columnCount == 1) {
                        Object value = null;
                        if (clazz.equals(int.class))
                            value = rs.getInt(1);
                        else if (clazz.equals(double.class))
                            value = rs.getDouble(1);
                        else if (clazz.equals(float.class))
                            value = rs.getFloat(1);
                        else if (clazz.equals(boolean.class))
                            value = rs.getBoolean(1);
                        else if (clazz.equals(long.class))
                            value = rs.getLong(1);
                        else if (clazz.equals(short.class))
                            value = rs.getShort(1);
                        else if (clazz.equals(byte.class))
                            value = rs.getByte(1);
                        else if (clazz.equals(char.class)) {
                            String s = rs.getString(1);
                            if (s.length() == 1)
                                value = s.charAt(0);
                        } else if (clazz.equals(Date.class))
                            value = rs.getTimestamp(1);
                        else if (clazz.equals(String.class))
                            value = rs.getString(1);
                        else if (clazz.equals(BigDecimal.class))
                            value = rs.getBigDecimal(1);
                        else
                            value = rs.getObject(1);
                        return (T) value;
                    }
                    return null;
                }

                Field[] fields = clazz.getDeclaredFields();
                if (fields.length == 0)
                    return null;
                Map<String, Field> columnDefinition = new HashMap<String, Field>();
                for (Field field : fields) {
                    if (Modifier.isFinal(field.getModifiers())
                            || Modifier.isStatic(field.getModifiers()) )
                        continue;
                    Column column = field.getAnnotation(Column.class);
                    columnDefinition.put(column.name().toLowerCase() , field);
                }
                if (columnDefinition.size() == 0)
                    return null;
                t = clazz.newInstance();
                for (int i = 1; i <= columnCount; i++){
                    Field field = columnDefinition.get(x.getColumnName(i).toLowerCase());
                    if (field != null) {
                        field.setAccessible(true);
                        Class<?> type = field.getType();
                        if (type.equals(int.class))
                            field.setInt(t, rs.getInt(i));
                        else if (type.equals(double.class))
                            field.setDouble(t, rs.getDouble(i));
                        else if (type.equals(float.class))
                            field.setFloat(t, rs.getFloat(i));
                        else if (type.equals(boolean.class))
                            field.setBoolean(t, rs.getBoolean(i));
                        else if (type.equals(long.class))
                            field.setLong(t, rs.getLong(i));
                        else if (type.equals(short.class))
                            field.setShort(t, rs.getShort(i));
                        else if (type.equals(byte.class))
                            field.setByte(t, rs.getByte(i));
                        else if (type.equals(char.class)) {
                            String s = rs.getString(i);
                            if (s.length() == 1)
                                field.setChar(t, s.charAt(0));
                        } else if (type.equals(Date.class))
                            field.set(t, rs.getTimestamp(i));
                        else if (type.equals(String.class))
                            field.set(t, rs.getString(i));
                        else if (type.equals(BigDecimal.class))
                            field.set(t, rs.getBigDecimal(i));
                        else
                            field.set(t, rs.getObject(i));
                    }
                }
            } catch (Exception e) {
                 e.printStackTrace() ; 
            }
            return t;
        }



}
package com.liyang.database;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Service;


@Service
public class SpringJdbcDBRunner extends AbstractDBRunner{


       @Autowired
       private JdbcTemplate  jdbcTemplate ;


        @Override
        public void execute(String sql, Object... values) throws Exception {

               if(sql == null || sql.trim().equals(""))
                     throw new Exception("sql为空") ;

               /*--输出测试--*/
               /*
               System.out.println(sql) ;
               for(Object e : values) System.out.println(e.toString());
               */
               jdbcTemplate.update(sql , values) ;
        }

        @Override
        public <T> List<T> find(final Class<T> clazz, String sql, Object... values) throws Exception {

              if(clazz == null)
                   throw new Exception("Class为空！") ;

              if(sql == null || sql.trim().equals(""))
                   throw new Exception("sql为空！") ;

              return  jdbcTemplate.query(sql , values , new RowMapper<T>(){

                    @Override
                    public T mapRow(ResultSet rs, int arg1) throws SQLException {

                           return extract(clazz, rs) ;
                    }

                }
              ) ;


        }


}

4、实体

package com.liyang.table;

import com.liyang.annotation.Table ; 
import com.liyang.annotation.Primary ;
import com.liyang.annotation.Column ;

@Table(name = "TWORKERSINFO")
public class Worker {

    @Primary
    @Column(name = "VC_id")
    private String  id ;

    @Column(name = "VC_workername")
    private String  workername ;

    @Column(name = "VC_sex")
    private String  sex ;

    @Column(name = "VC_salary")
    private String  salary ;

    @Column(name = "VC_email")
    private String  email ;

    @Column(name = "VC_employedDates")
    private String  employedDates ;

    @Column(name = "VC_department")
    private String  department ;


    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getWorkername() {
        return workername;
    }
    public void setWorkername(String workername) {
        this.workername = workername;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getSalary() {
        return salary;
    }
    public void setSalary(String salary) {
        this.salary = salary;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public String getEmployedDates() {
        return employedDates;
    }
    public void setEmployedDates(String employedDates) {
        this.employedDates = employedDates;
    }
    public String getDepartment() {
        return department;
    }
    public void setDepartment(String department) {
        this.department = department;
    }

}

5、工具类

package com.liyang.utils;

import java.text.ParseException;  
import java.text.SimpleDateFormat;  
import java.util.Calendar;
import java.util.Date;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class DateUtils {
       private  static final Log logger = LogFactory.getLog(DateUtils.class) ;

       public static   long DiffDate(String dateA , String dateB){
                SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd");  
                long to = 0 ;
                try {
                    to = df.parse(dateB).getTime();
                } catch (ParseException e) {
                    logger.error("转换错误"); 
                }  
                long from = 0 ;
                try {
                    from = df.parse(dateA).getTime();
                } catch (ParseException e) {
                    logger.error("转换错误"); 
                }  
                long dif = (from - to) / (1000 * 60 * 60 * 24) ;
                return Math.abs(dif)  ;
       }

       public static  long DiffDate(String dateA , String dateB , String form){ //"yyyyMMddHHmmss"
            SimpleDateFormat df = new SimpleDateFormat(form) ;  
            long to = 0 ;
            try {
                to = df.parse(dateB).getTime();
            } catch (ParseException e) {
                logger.error("转换错误"); 
            }  
            long from = 0 ;
            try {
                from = df.parse(dateA).getTime();
            } catch (ParseException e) {
                logger.error("转换错误"); 
            }  
            long dif = (from - to) / (1000 * 60 * 60 * 24) ;
            return Math.abs(dif)  ;
      }

       public  static String getNowTime(String format){ 
               SimpleDateFormat df = new SimpleDateFormat(format) ;
               return df.format(new Date()) ;
       }

       public  static String getNowTime(){ 
               return getNowTime("yyyyMMddHHmmss") ;
       }

       public   static String getDate(String format){ //"yyyyMMdd"
                SimpleDateFormat df = new SimpleDateFormat(format);  
                return df.format(new Date()) ;
       }

       public   static String getTime(String format){ //"HHmmss"
                SimpleDateFormat df = new SimpleDateFormat(format);  
                return df.format(new Date()) ;
       }

       public  static  String GetMillitme(){
               return String.format("%03d", Integer.valueOf(getTime("SS") ))  ;            
       }

       public  static  String GetNextDate(String day , String format){ //"yyyyMMdd"
                 String nextday = null ;
                 Calendar cal = Calendar.getInstance(); 
                 Date date = new Date(); 
                 SimpleDateFormat sdf = new SimpleDateFormat(format) ; 
                 try{ 
                     date = sdf.parse(day) ; 
                     cal.setTime(date); 
                     cal.add(cal.DATE, 1); 
                     System.out.println("下一天的时间是：" + sdf.format(cal.getTime())); 
                     nextday = sdf.format(cal.getTime())  ;
                 } 
                 catch (Exception e){ 
                     logger.error("转换错误");  
                 } 
                 return nextday  ;
       }

       public  static  String GetLastDate(String day , String format){ //"yyyyMMdd"
             String nextday = null ;
             Calendar cal = Calendar.getInstance(); 
             Date date = new Date(); 
             SimpleDateFormat sdf = new SimpleDateFormat(format) ; 
             try{ 
                 date = sdf.parse(day) ; 
                 cal.setTime(date); 
                 cal.add(cal.DATE, -1); 
                 System.out.println("上一天的时间是：" + sdf.format(cal.getTime())); 
                 nextday = sdf.format(cal.getTime())  ;
             } 
             catch (Exception e){ 
                 logger.error("转换错误");  
             } 
             return nextday  ;
      }

       public static void main(String[] args){
           //   System.out.println(DateUtils.DiffDate("20120102", "20130102")); 
     //          System.out.println(  GetMillitme() ) ;
//            SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd");//设置日期格式
//            System.out.println(df.format(new Date()));// new Date()为获取当前系统时间
//            
//            System.out.println(getDate("yyyyMMdd")) ;
//            

//            
//            System.out.println(DateUtils.GetNextDate("20150131", "yyyyMMdd"));
//            System.out.println(DateUtils.GetLastDate("20150131", "yyyyMMdd"));

              System.out.println(getNowTime());

       }
}

6、测试

package com.liyang.test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Service;

import com.liyang.database.SpringJdbcDBRunner;
import com.liyang.table.Worker;
import com.liyang.utils.DateUtils; 


@Service
public class Test {

        @Autowired
        public  static SpringJdbcDBRunner  jdbc ;

        public static void main(String[] args) throws Exception {

                String[] configLocations = { "applicationContext-base.xml" , "applicationContext-resource.xml" };
                ApplicationContext context = new ClassPathXmlApplicationContext(configLocations);

                jdbc = context.getBean("springJdbcDBRunner" , SpringJdbcDBRunner.class) ;
               //注意：首字母务必小写

                Worker  woker = new Worker() ;
                woker.setWorkername("老李");
                woker.setSex("M") ;
                woker.setEmail("1653921362@qq.com");
                woker.setDepartment(DateUtils.getNowTime()) ;
                jdbc.insert(woker) ;


        }

}

7、配置
applicationContext-base.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans default-autowire="byName"
    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:tx="http://www.springframework.org/schema/tx"
    xmlns:task="http://www.springframework.org/schema/task"
    xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
       http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.2.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">

    <task:annotation-driven />

    <tx:annotation-driven />

    <context:component-scan base-package="com.liyang" />

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

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource">
            <ref bean="dataSource" />
        </property>
    </bean>

</beans>

applicationContext-resource.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans default-autowire="byName"
    xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver">
        </property>
        <property name="url"
            value="jdbc:mysql://X.X.X.X:3306/databasename?rewriteBatchedStatements=true&amp;useUnicode=true&amp;characterEncoding=utf8">
        </property>
        <property name="username" value="oms"></property>
        <property name="password" value="oms"></property>
        <property name="maxActive" value="50"></property>
        <property name="maxIdle" value="50"></property>
        <property name="minIdle" value="10"></property>
        <property name="maxWait" value="60000"></property>
        <property name="removeAbandoned" value="true"></property>
        <property name="removeAbandonedTimeout" value="180"></property>
    </bean>

</beans>

8.结果
这里写图片描述

贫嘴小李子的幸福生活
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot项目整合mybatis、springmvc、JDBC
weixin_54685622的博客
03-27 3232
常用注解 @Configuration 标识当前类是配置类 @ComponentScan 包扫描注解 扫描注解 @Bean 标识该方法的返回值交给Spring容器管理 @Scope 控制多例和单例 @Lazy 懒加载 @PostConstruct 初始化方法 @PreDestroy 销毁方法 @Component 将当前类未来的对象交给容器管理 @Autowired 按照类型进行注入 @Qualifier 按照名称进行注入 @Repository 标识持久层注解 @Service 标识Service层 @C
Spring MVC 和Spring JDBC
最新发布
Elaine2391的博客
10-14 500
简单了解SpringMVC和SpringJDBC
Spring引入jdbc操作数据库超详细学习笔记
越努力越幸运的博客
08-13 6082
文章目录四、Spring引入jdbc操作数据库4.1 JdbcTemplate准备工作4.2 jdbc操作数据库添加数据4.3 jdbc操作数据库修改和删除数据4.4 jdbc操作数据库查询数据4.4.1 查询返回数据4.4.2 查询返回对象4.4.3 查询返回集合4.5 jdbc操作数据库批量增加数据4.6 jdbc操作数据库批量修改和删除数据 四、Spring引入jdbc操作数据库 4.1 JdbcTemplate准备工作 Spirng框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库
springMVC框架学习 JdbcTemplate的基本操作
m0_59588838的博客
03-15 716
之前测试过数据源对象的使用：http://t.csdn.cn/cs3Xq，主要是以下四个内容：1、C3P0数据源，2、Druid数据源，3、利用spring为我们创建数据源，4、利用jdbc.properties解耦。 今天学习了jdbcTemplate模板的使用，比mybatis肯定差很多，毕竟ssm目前来看还是比较流行的，至于之后的Boot框架等我把ssm进度走完了在学习。jdbcTemplate最直观的就是它通过进行mysql语句与java语句的混合编写来实现功能，而不是像mybatis一样在xml
spring+springMvc+jdbc 简易框架整合
11-01
自己做得简易 spring+springMvc+jdbc整合，可改进内容还很多，仅仅是个demo，tomcat使用的8.0
springmvc jdbc的增删改查
02-10
JDBC（Java Database Connectivity）则是Java编程语言中用于与数据库交互的一种标准API。在Spring MVC项目中集成JDBC，可以方便地进行数据的增删改查操作，无需编写大量重复的SQL代码。下面我们将深入探讨这两个技术...
springmvc+jdbc数据库实例
07-18
在这个"springmvc+jdbc数据库实例"中，我们将会探讨如何在Spring MVC项目中集成JDBC来操作MySQL数据库。 首先，我们需要在Maven工程中添加相应的依赖。Spring MVC和JDBC相关的库，如Spring Web、Spring JDBC、MySQL...
springMvc jdbc jQWidgets项目案例jasperreport自动化报表系统
06-09
课程从项目需求为开始，为了实现一套报表自动化系统，而做的相关功能开发。目的：部署这套系统后，...技术包括：jqwidgets(html5)、springmvc、jdbc、log4j、Jasperreport、Javamail、spring task、文件上传、下载等。
SpringMVC+SpringJDBC
02-02
SpringMVC和SpringJDBC是Java开发中两个重要的框架，它们分别是Spring框架在Web层和数据访问层的应用。本文将详细介绍这两个组件的核心概念、工作原理以及如何整合使用，旨在帮助开发者更好地理解和应用。 **...
SpringJDBC结合SpringMVC
FF小迷糊吖~
05-18 464
Spring雪梨作业之SpringJDBC结合SpringMVC
spring mvc jdbc 连接数据库配置说明
03-20
spring mvc jdbc 连接数据库配置说明
SpringMVC+Spring+SpringJDBC
02-02
SpringMVC+Spring+SpringJDBC 整合好的，能正常跑起来
Spring MVC JDBC 项目 事例 实例
08-06
Spring spring mvc MVC jdbc JDBC 例子 项目 springMVC+jdbc完全事例，不含其他框架。 增删改差齐全，数据库oracle。表结构等没有上传，根据bean自己写很简单的
SpringMVC+Spring+SpringJDBC整合框架
04-21
Spring，SpringMVC，SpringJDBC整合实现了登录功能，对于刚学习SpringMVC的同学来说应该是个不错的基础框架！
SpringMVC+JDBC快速搭建(使用注解)
08-10
NULL 博文链接：https://775265430.iteye.com/blog/2213253
Spring MVC+JDBC 学习笔记
weixin_41750142的博客
10-03 353
新建工程springmvcdemo即相应的包： 并将输出路径改为Tomcat的webapps下: 部署完毕后运行Tomcat，浏览器页面显示“Hello world！”，说明Tomcat工作正常。 在pom.xml中添加mysql、SpringMVC相关等依赖： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="h...
Java Spring MVC 中使用JdbcTemplate示例
allway2的博客
11-03 1013
Spring 通过使用jdbcTemplate和org.springframework.jdbc.core和相关包中的相关类，使使用 JDBC 变得容易。有关JdbcTemplate 基础知识的介绍性教程，请参阅：Spring JDBC 模板简单示例。本教程通过演示如何在Spring MVC应用程序中集成JdbcTemplate来进一步。本教程中的示例应用程序管理如下所示的联系人列表：示例应用程序是使用以下软件/技术开发的（当然，您可以使用较新的版本）： 执行以下 MySQL 脚本以创建名为contactd
Spring+SpringMVC+JdbcTemplate整合（案例）
weixin_45060598的博客
11-18 1810
1.创建maven-webapp项目 2.在pom.xml中引入依赖 <properties> <spring.version>5.3.12</spring.version> </properties> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>jun..
mysql的创建表有1113错误_MYSQL创建表的错误
weixin_35332816的博客
01-20 903
DROPTABLEIFEXISTS`user`;CREATETABLE`user`(`intID`int(11)NOTNULLauto_increment,`vcName`varchar(20)NOTNULL,`vcPassword`varchar(20)NOTNULL,`vcSex`varchar(2)NOTNULL,PRIMARYKE...DROP TABLE IF EXISTS `user`...
springMVC配置jdbc
05-10
可以参考以下步骤进行SpringMVC配置JDBC： 1. 在pom.xml文件中添加Maven依赖: ```xml <groupId>org.springframework <artifactId>spring-jdbc <version>5.2.5.RELEASE <groupId>mysql <artifactId>mysql-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值