jdbctemplate 新增 nvarchar2类型
时间: 2023-11-01 12:11:21 浏览: 107
JdbcTemplate 是 Spring 提供的 JDBC 抽象层,它提供了一系列的方法来简化 JDBC 操作。对于 nvarchar2 类型,可以使用 JdbcTemplate 的 `update` 方法来进行新增操作。
在执行 SQL 语句时,需要使用占位符来代替实际的参数值,以防止 SQL 注入攻击。对于 nvarchar2 类型,可以使用 `setString` 方法来设置参数值。例如:
```
String sql = "INSERT INTO my_table (id, name) VALUES (?, ?)";
jdbcTemplate.update(sql, 1, "张三");
```
在上面的示例中,`?` 是占位符,`setString` 方法将字符串参数设置为 nvarchar2 类型。如果需要设置其他类型的参数,可以使用相应的 `setXXX` 方法,例如 `setInt`、`setDate` 等等。
相关问题
使用SpringMVC编写代码实现图书的新增功能 1.编写视图层JSP代码,页面提供表单,由用户填写图书名称,出版社,出版日期,作者,定价,ISBN并提交。 2.编写控制层Java代码,获取视图层提交的表单请求,控制方法注入表单项参数,控制层完成JavaBean封装和业务层代码调用。 3.编写业务层Java代码,将控制层传输的JavaBean进行非空校验然后调用持久层代码。 4.编写持久层Java代码,将经过控制层校验的JavaBean转换成SQL语句并向MySQL数据库Test的book表插入一条新增记录。 5.编写视图层JSP代码,显示新增成功或者失败及失败原因。 其中,Test数据库的book表结构如下表1所示: 表1:book表结构 字段ID 字段名称 字段类型 约束 bookId 图书编号 int 非空,自增长,主键 bookName 图书名称 varchar(30) 非空 press 出版社 varchar(20) 非空 pressDate 出版日期 date 非空,不晚于当前时间 author 作者 varchar(10) 非空 price 定价 money 非空 ISBN ISBN char(13) 非空 注意事项: 1.页面表单不需要填写图书编号,而交给数据库自增长生成编号。 2.持久层代码使用JDBC完成,允许使用ORM框架。 3.必须使用SpringMVC框架,可以使用Spring的IoC。
下面是代码实现:
1. 编写视图层JSP代码,页面提供表单
```jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>新增图书</title>
</head>
<body>
<h2>新增图书</h2>
<form action="addBook" method="post">
<label>图书名称:</label>
<input type="text" name="bookName" required><br>
<label>出版社:</label>
<input type="text" name="press" required><br>
<label>出版日期:</label>
<input type="date" name="pressDate" required><br>
<label>作者:</label>
<input type="text" name="author" required><br>
<label>定价:</label>
<input type="number" name="price" required><br>
<label>ISBN:</label>
<input type="text" name="ISBN" required><br>
<input type="submit" value="提交">
</form>
</body>
</html>
```
2. 编写控制层Java代码,获取视图层提交的表单请求,控制方法注入表单项参数,控制层完成JavaBean封装和业务层代码调用。
```java
@Controller
public class BookController {
@Autowired
private BookService bookService;
@RequestMapping("/addBook")
public ModelAndView addBook(@RequestParam("bookName") String bookName,
@RequestParam("press") String press, @RequestParam("pressDate") Date pressDate,
@RequestParam("author") String author, @RequestParam("price") BigDecimal price,
@RequestParam("ISBN") String ISBN) {
Book book = new Book();
book.setBookName(bookName);
book.setPress(press);
book.setPressDate(pressDate);
book.setAuthor(author);
book.setPrice(price);
book.setISBN(ISBN);
String result = bookService.addBook(book);
ModelAndView modelAndView = new ModelAndView();
if(result == null) {
modelAndView.setViewName("add_result");
modelAndView.addObject("result", "添加成功");
} else {
modelAndView.setViewName("add_result");
modelAndView.addObject("result", "添加失败,原因:" + result);
}
return modelAndView;
}
}
```
3. 编写业务层Java代码,将控制层传输的JavaBean进行非空校验然后调用持久层代码。
```java
@Service
public class BookService {
@Autowired
private BookDao bookDao;
public String addBook(Book book) {
if(book.getBookName() == null || book.getBookName().equals("")) {
return "图书名称不能为空";
}
if(book.getPress() == null || book.getPress().equals("")) {
return "出版社不能为空";
}
if(book.getPressDate() == null || book.getPressDate().after(new Date())) {
return "出版日期不能为空且不能晚于当前时间";
}
if(book.getAuthor() == null || book.getAuthor().equals("")) {
return "作者不能为空";
}
if(book.getPrice() == null || book.getPrice().compareTo(BigDecimal.ZERO) <= 0) {
return "定价不能为空且必须大于0";
}
if(book.getISBN() == null || book.getISBN().equals("")) {
return "ISBN不能为空";
}
try {
bookDao.addBook(book);
return null;
} catch(Exception e) {
e.printStackTrace();
return "数据库异常";
}
}
}
```
4. 编写持久层Java代码,将经过控制层校验的JavaBean转换成SQL语句并向MySQL数据库Test的book表插入一条新增记录。
```java
@Repository
public class BookDao {
@Autowired
private JdbcTemplate jdbcTemplate;
public void addBook(Book book) {
String sql = "insert into book(bookName, press, pressDate, author, price, ISBN) values (?, ?, ?, ?, ?, ?)";
jdbcTemplate.update(sql, book.getBookName(), book.getPress(), book.getPressDate(), book.getAuthor(), book.getPrice(), book.getISBN());
}
}
```
5. 编写视图层JSP代码,显示新增成功或者失败及失败原因。
```jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>新增结果</title>
</head>
<body>
<h2>${result}</h2>
<a href="addBookPage">返回</a>
</body>
</html>
```
注意事项:
1. 页面表单不需要填写图书编号,而交给数据库自增长生成编号。
2. 持久层代码使用JDBC完成,允许使用ORM框架。
3. 必须使用SpringMVC框架,可以使用Spring的IoC。
提交要求:
1. 使用eclipseForJavaEE进行开发。
2. 将代码打包成war包并上传至服务器,提供war包下载链接。
3. 提供MySQL数据库Test的book表结构及插入数据的SQL语句。
MySQL数据库Test的book表结构及插入数据的SQL语句如下:
```sql
CREATE TABLE `book` (
`bookId` int(11) NOT NULL AUTO_INCREMENT COMMENT '图书编号',
`bookName` varchar(30) NOT NULL COMMENT '图书名称',
`press` varchar(20) NOT NULL COMMENT '出版社',
`pressDate` date NOT NULL COMMENT '出版日期',
`author` varchar(10) NOT NULL COMMENT '作者',
`price` decimal(10,2) NOT NULL COMMENT '定价',
`ISBN` char(13) NOT NULL COMMENT 'ISBN',
PRIMARY KEY (`bookId`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COMMENT='图书';
```
连接实验一的数据库,操作商品表,利用JdbcTemplate进行增、删、改、查操作。
好的,让我们一步步来进行操作。
首先,需要在项目中引入JdbcTemplate。如果你是使用Spring Boot创建的项目,JdbcTemplate已经包含在`spring-boot-starter-jdbc`依赖中,无需再次引入。如果你使用的是普通的Spring项目,需要在Maven或Gradle配置文件中添加以下依赖:
```xml
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
```
或者
```groovy
implementation 'org.springframework:spring-jdbc:5.2.5.RELEASE'
```
接下来,我们需要在项目的配置文件中添加数据库的连接信息,例如:
```properties
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=123456
```
其中,`driver-class-name`是数据库驱动名称,`url`是数据库连接地址,`username`和`password`是数据库的用户名和密码。
接下来,我们可以在代码中使用JdbcTemplate进行增、删、改、查操作。以操作商品表为例,假设商品表的结构如下:
```sql
CREATE TABLE `product` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) DEFAULT NULL,
`price` decimal(10,2) DEFAULT NULL,
`create_time` datetime DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
```
那么,可以定义一个`Product`类来映射商品表:
```java
public class Product {
private Long id;
private String name;
private BigDecimal price;
private LocalDateTime createTime;
// getter/setter省略
}
```
接下来,我们可以定义一个`ProductDao`类来操作商品表:
```java
@Repository
public class ProductDao {
@Autowired
private JdbcTemplate jdbcTemplate;
/**
* 新增商品
*/
public void addProduct(Product product) {
String sql = "INSERT INTO product (name, price, create_time) VALUES (?, ?, ?)";
jdbcTemplate.update(sql, product.getName(), product.getPrice(), product.getCreateTime());
}
/**
* 删除商品
*/
public void deleteProduct(Long id) {
String sql = "DELETE FROM product WHERE id = ?";
jdbcTemplate.update(sql, id);
}
/**
* 修改商品
*/
public void updateProduct(Product product) {
String sql = "UPDATE product SET name = ?, price = ?, create_time = ? WHERE id = ?";
jdbcTemplate.update(sql, product.getName(), product.getPrice(), product.getCreateTime(), product.getId());
}
/**
* 查询商品列表
*/
public List<Product> listProducts() {
String sql = "SELECT id, name, price, create_time FROM product";
return jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Product.class));
}
/**
* 根据ID查询商品
*/
public Product getProductById(Long id) {
String sql = "SELECT id, name, price, create_time FROM product WHERE id = ?";
return jdbcTemplate.queryForObject(sql, new Object[]{id}, new BeanPropertyRowMapper<>(Product.class));
}
}
```
其中,`@Repository`注解用于声明该类是一个数据访问对象(DAO),`@Autowired`注解用于自动注入`JdbcTemplate`对象。`addProduct`、`deleteProduct`、`updateProduct`方法分别用于新增、删除、修改商品,`listProducts`方法用于查询商品列表,`getProductById`方法用于根据ID查询商品。
最后,我们可以在Controller中调用`ProductDao`类的方法来操作商品表:
```java
@RestController
@RequestMapping("/product")
public class ProductController {
@Autowired
private ProductDao productDao;
/**
* 新增商品
*/
@PostMapping
public void addProduct(@RequestBody Product product) {
productDao.addProduct(product);
}
/**
* 删除商品
*/
@DeleteMapping("/{id}")
public void deleteProduct(@PathVariable Long id) {
productDao.deleteProduct(id);
}
/**
* 修改商品
*/
@PutMapping("/{id}")
public void updateProduct(@PathVariable Long id, @RequestBody Product product) {
product.setId(id);
productDao.updateProduct(product);
}
/**
* 查询商品列表
*/
@GetMapping
public List<Product> listProducts() {
return productDao.listProducts();
}
/**
* 根据ID查询商品
*/
@GetMapping("/{id}")
public Product getProductById(@PathVariable Long id) {
return productDao.getProductById(id);
}
}
```
以上就是利用JdbcTemplate进行增、删、改、查操作的完整代码。需要注意的是,本例中使用了`@RestController`、`@PostMapping`、`@DeleteMapping`、`@PutMapping`、`@GetMapping`等注解,需要引入`spring-web`依赖。
阅读全文