SSM学习笔记

Spring

以IOC（控制反转）和AOP（面向切面编程）为内核

一、快速入门，写一个Spring小项目 1. 先用maven创建web项目

File–New–Module，左侧选择Maven，勾上create from archetype，找到maven-archetype-webapp,即可

完成后，对着main 右键new directory，resources和java

对着src 右键new directory，test,对着test 右键new directory，resources和java

2. 加入依赖

在pom.xml，加入依赖，碰到报红，点右侧maven，刷新，如果是没有的jar包，idea会自动下载

  
      org.springframework
      spring-context
      5.0.5.RELEASE

3. 做dao实现（Service层也一样操作）

对着src/main/java右键，new== interface==命名com.tang.dao.UserDao

package com.tang.dao;

public interface UserDao {
    public void save();
}

对着src/main/java/com.tang.dao右键，new== java class==命名impl.UserDaoImpl

package com.tang.dao.impl;

import com.tang.dao.UserDao;

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("save running...");
    }
}

4. 配置文件applicationContext

对着src/main/resources右键，new== xml==spring config 命名为applicationContext，加入以下代码

5. 测试代码

对着src/main/java右键，new==class 命名为com.tang.demo.UserDaoDemo

package com.tang.demo;

import com.tang.dao.UserDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserDaoDemo {
    public static void main(String[] args) {
        ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao=(UserDao) app.getBean("userDao");
        userDao.save();
    }
}

//不用跑Tomcat，点击左侧绿色箭头，run一下，控制台输出  save running...  说明成功

二、Spring配置文件

都是在applicationContext.xml里进行配置文件

2.1 Bean标签基本配置

用于配置对象交由Spring来创建

默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功

id：Bean实例在Spring容器中的唯一标识

class:Bean的权限定名

2.2 Bean标签范围配置

scope：指对象的作用范围，取值如下：常用singleton和prototype

取值范围	说明
singleton	默认值，单例的，单一对象
prototype	多例的，容器中存的对象的hashcode不一样，代表不是一个对象
request，了解	WEB项目中，Spring创建一个Bean的对象，将对象存入到request域中
session，了解	WEB项目中，Spring创建一个Bean的对象，将对象存入到session域中
global session，了解	WEB项目中，应用在Portlet环境，如果没有Portlet环境那么相当于session

单列对象：scope=“singleton”

Bean的实例化个数：1个

Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例

Bean的生命周期：

对象创建：当应用加载时，创建容器时，对象就被创建了。

对象运行：只要容器在，对象一直活着。

对象销毁：当应用卸载，销毁容器时，对象就被销毁了。

多例对象：scope=“prototype”

Bean的实例化个数：多个

Bean的实例化时机：当调用getBean()实例化Bean

Bean的生命周期：

对象创建：当使用对象时，创建新的对象实例

对象运行：只要对象在使用中，就一直活着

对象销毁：当对象长时间不用时，被Java的垃圾回收器回收了

2.3 Bean生命周期配置

init-method：指定类中的初始化方法名称

destroy-method：指定类中销毁方法名称

2.4 Bean实例化的三种方式

无参构造方法实例化

工厂静态方法实例化

package com.tang.factory;

import com.tang.dao.UserDao;
import com.tang.dao.impl.UserDaoImpl;

public class StaticFactory {

    public static UserDao getUserDao(){
        return new UserDaoImpl();
    }
}
===================================================================================
 //   applicationContext配置文件加入一行代码

工厂实例方法实例化

package com.tang.factory;

import com.tang.dao.UserDao;
import com.tang.dao.impl.UserDaoImpl;

public class StaticFactory {

    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

===================================================================================
 //   applicationContext配置文件加入一行代码

2.5 Bean依赖注入分析

因为UserService和UserDao都在Spring容器中，而最终程序直接使用的是UserService，所以可以在Spring容器中，将UserDao设置到UserService内部

依赖注入：它是Spring框架核心IOC的具体实现，框架把持久层对象传入业务层，而不用我们自己去获取

2.6 Bean依赖注入三种方式

怎么将UserDao注入到UserService内部呢？

set方法

    
   
  
   
===================================================================================
package com.tang.service.impl;

import com.tang.dao.UserDao;
import com.tang.service.UserService;

public class UserServiceImpl implements UserService {
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void save() {
        userDao.save();
    }
}

P命名空间注入本质也是set方法注入

首先要引入P命名空间

applicationContext最上面 插入以下代码
xmlns:p="http://www.springframework.org/schema/p"

其次要修改注入方式

构造方法，有参构造注入

     
    
        
    
===================================================================================
package com.tang.service.impl;

import com.tang.dao.UserDao;
import com.tang.service.UserService;

public class UserServiceImpl implements UserService {
    private UserDao userDao;
    public UserServiceImpl() {

    }
    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void save() {
        userDao.save();
    }
}

2.7 Bean依赖注入数据类型

上面的操作，都是注入的引用Bean，除了对象的引用可以注入，普通数据类型，集合等都可以在容器中进行注入

注入数据的三种数据类型：普通数据类型，引用数据类型，集合数据类型

注入普通数据类型

package com.tang.dao.impl;

import com.tang.dao.UserDao;

public class UserDaoImpl implements UserDao {
    private String username;
    private int age;

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

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public void save() {
        System.out.println(username+"==="+age);
        System.out.println("save running...");
    }
}
=====================================================================================

2.8 引入其他配置文件（分模块开发）

实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以可以将部分配置拆解到其他配置文件中，而在Spring主配置文件通过import标签进行加载，比如公司拆解，你负责用户模块，他负责产品模块

三、Spring相关API 3.1 ApplicationContext继承体系

applicationContext：接口类型，代表应用上下文，可以通过他的实例获得Spring容器中的Bean对象

3.2 ApplicationContext的实现类

ClassPathXmlApplicationContext 它是从类的根路径下加载配置文件，推荐使用这个
FileSystemXmlApplicationContext 它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置
AnnotationConfigApplicationContext 当使用注解配置容器对象时，需要使用此类来创建Spring容器，它用来读取注解

3.3 getBean

app.getBean(“id”) 如果容器中某一类型的bean存在多个，就要id方式获取

app.getBean(class) 如果容器中某一类型的bean存在1个，就可以用类方式获取

四、Spring配置数据源

使用连接池配置数据源

4.1 数据源（连接池）的作用

为提高程序性能而出现的
事先实例化数据源，初始化部分连接资源
使用连接资源时从数据源中获取
使用完毕后将连接资源归还给数据源

4.2 数据源的开发步骤

导入数据源的坐标和数据库驱动坐标
创建数据源对象
设置配置文件，有mysql驱动，用户名密码，连接池的初始化连接个数，最大等待个数等等
使用数据源获取连接资源和归还连接资源

4.3 手动创建Druid和C3P0数据源（没用配置文件）

在pom.xml里面添加以下代码

	
      mysql
      mysql-connector-java
      5.1.47
    

    
      com.alibaba
      druid
      1.1.21
    

    
      c3p0
      c3p0
      0.9.1.2

//   src/test/java 右键 new--java class  命名为com.tang.test.DataSourceTest

package com.tang.test;

import com.alibaba.druid.pool.*;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.Test;

import java.sql.Connection;

public class DataSourceTest {
    @Test
    //测试手动创建druid数据源
    public void test2() throws Exception{
        DruidDataSource dataSource=new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/companydb");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");

        DruidPooledConnection connection=dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }
    @Test
    //测试手动创建c3p0数据源
    public void test1() throws Exception{
        ComboPooledDataSource dataSource=new ComboPooledDataSource();
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/companydb");
        dataSource.setUser("root");
        dataSource.setPassword("123456");

        Connection connection=dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }
}

//输出的connection的哈希值，证明不是空的就行

4.4 C3P0数据源用配置文件读取

// src-test-resources  下新建 File 命名为jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/companydb?useUnicode=true&characterEncoding=utf-8&useSSL=false
jdbc.username=root
jdbc.password=123456
======================================================================================
  @Test
    //测试手动创建c3p0数据源
    public void test2() throws Exception{
        //读取配置文件
        ResourceBundle rb=ResourceBundle.getBundle("jdbc");
        String driver=rb.getString("jdbc.driver");
        String url=rb.getString("jdbc.url");
        String username=rb.getString("jdbc.username");
        String password=rb.getString("jdbc.password");

        //创建数据源对象，设置连接参数
        ComboPooledDataSource dataSource=new ComboPooledDataSource();
        dataSource.setDriverClass(driver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);

        Connection connection= dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }

4.5 Spring配置数据源

可以将DataSource的创建权交给Spring容器去完成

这边以C3P0举例

public class DataSourceTest {
    @Test
    //测试Spring容器产生数据源对象
    public void test2() throws Exception{
        //读取配置文件
        ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
        DataSource dataSource=app.getBean(DataSource.class);
        Connection connection= dataSource.getConnection();
        System.out.println(connection);
        connection.close();

    }
}

 applicationContext.xml

4.6 Spring抽取jdbc配置文件

// src-test-resources  下新建 File 命名为jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/companydb?useUnicode=true&characterEncoding=utf-8&useSSL=false
jdbc.username=root
jdbc.password=123456
===================================================================================

    applicationContext.xml  


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 http://www.springframework.org/schema/context/spring-context.xsd">

五、Spring注解开发（需要配置组件扫描） 5.1 Spring原始注解

Spring原始注解主要是替代的配置，需要配置组件扫描

注解	说明
@Component	使用在类上用于实例化Bean
@Controller	使用在web层类上用于实例化Bean
@Service	使用在service层类上用于实例化Bean
@Repository	使用在dao层类上用于实例化Bean
@Autowired	使用在字段上用于根据类型依赖注入
@Qualifier	结合@Autowired一起使用用于根据名称进行依赖注入
@Resource	相当于@Autowired+@Qualifier，按照名称进行注入
@Value	注入普通属性
@Scope	标注Bean的作用范围
@PostConstruct	使用在方法上标注该方法是Bean的初始化方法
@PreDestroy	使用在方法上标注该方法是Bean的销毁方法

注意：

使用注解进行开发时，需要在applicationContext.xml 中配置组件扫描，作用是指定哪个包及其子包下的Bean需要进行扫描以便识别使用注解配置的类、字段和方法

5.2 Spring新注解

注解	说明
@Configuration	用于指定当前类是一个Spring配置类，当创建容器时会从该类上加载注解
@ComponentScan	用于指定Spring在初始化容器时要扫描的包。作用和在Spring 的xml配置文件中的—样
@Bean	使用在方法上，标注将该方法的返回值存储到Spring容器中
@PropertySource	用于加载.properties文件中的配置
@import	用于导入其他配置类

六、Spring集成Junit 6.1 原始Junit测试Spring的问题

在测试类中，每个测试方法都有以下两行代码：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import javax.servlet.*;
import javax.sql.DataSource;

ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
DataSource dataSource=app.getBean(DataSource.class);

这两行代码的作用是获取容器，如果不写的话，直接会提示空指针异常，所以又不能轻易删掉

6.2 上述问题解决思路

让SpringJunit负责创建Spring容器，但是需要将配置文件的名称告诉它
将需要进行测试Bean直接在测试类中进行注入

6.3 Spring集成Junit步骤

（1）导入Spring集成Junit的坐标


  org.springframework
  spring-test
  5.0.5.RELEASE

（2）使用@Runwith注解替换原来的运行期

（3）使用@ContextConfiguration指定配置文件或配置类

（4）使用@Autowired注入需要测试的对象

（5）创建测试方法进行测试

package com.tang.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringJunitTest {
    @Autowired
    private UserService userService;
    
    @Test
    public void test1(){
        userService.save();
    }
}

七、Spring集成Web环境

	多加以下两个
	
	
      javax.servlet
      javax.servlet-api
      3.1.0
    

    
      javax.servlet.jsp
      javax.servlet.jsp-api
      2.2.1

7.1 ApplicationContext应用上下文获取方式

应用上下文对象是通过newClasspathXmIApplicationContext(spring配置文件)方式获取的，但是每次从容器中获得Bean时都要编写new ClasspathXmIApplicationContext(spring配置文件)，这样的弊端是配置文件加载多次，应用上下文对象创建多次。

在Web项目中，可以使用ServletContextListener监听Web应用的启动，我们可以在Web应用启动时，就加载Spring的配置文件，创建应用上下文对象ApplicationContext，在将其存储到最大的域servletContext域中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了。

7.2 Spring提供获取应用上下文的工具

上面的分析不用手动实现，Spring提供了一个监听器ContextLoaderListener就是对上述功能的封装，该监听器内部加载Spring配置文件，创建应用上下文对象，并存储到ServletContext域中，提供了一个客户端工具WebApplicationContextUtils供使用者获得应用上下文对象。

所以我们需要做的只有两件事:

(1)在web.xml中配置ContextLoaderListener监听器（导入spring-web坐标)

pom.xml


  org.springframework
  spring-web
  5.0.5.RELEASE

======================================================================================
web.xml


  contextConfigLocation
  classpath:applicationContext.xml

  
  
  org.springframework.web.context.ContextLoaderListener

(2)使用WebApplicationContextUtils获得应用上下文对象ApplicationContext

public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

  
        ServletContext servletContext=this.getServletContext();
        ApplicationContext app=WebApplicationContextUtils.getWebApplicationContext(servletContext);
        UserService userService=app.getBean(UserService.class);
        userService.save();
    }
}

八、Spring的事务控制 8.1 编程式事务控制相关对象

PlatformTransactionManager(获取事务的状态信息，提交事务，回滚事务)
TransactionDefinition（获得的事务的隔离级别，传播行为，获得超时时间，是否只读）
TransactionStatus（是否存储回滚点，事务是否完成，是否是新事务，事务是否回滚）

8.2 基于XML的声明式事务控制 8.3 基于注解的声明式事务控制 SpringMVC

目前可以简单理解，JavaBean=POJO=entity。但实际三个不一样，JavaBean可能会写点简单的业务逻辑

一、快速入门，写一个SpringMVC小项目 1. 先用maven创建web项目

File–New–Module，左侧选择Maven，勾上create from archetype，找到maven-archetype-webapp,即可

完成后，对着main 右键new directory，resources和java

对着src 右键new directory，test,对着test 右键new directory，resources和java

2. 加入依赖，配置控制器DispatcherServlet

在pom.xml，加入依赖，碰到报红，点右侧maven，刷新，如果是没有的jar包，idea会自动下载

  
      junit
      junit
      4.12
      test
    
    
      javax.servlet
      javax.servlet-api
      3.1.0
    

    
      javax.servlet.jsp
      javax.servlet.jsp-api
      2.2.1
    
    
      org.springframework
      spring-context
      5.0.5.RELEASE
    
    
      org.springframework
      spring-web
      5.0.5.RELEASE
    
    
      org.springframework
      spring-webmvc
      5.0.5.RELEASE

在web.xml，配置SpringMVC的前端控制器，DispatcherServlet




  
  DispatcherServlet
  org.springframework.web.servlet.DispatcherServlet
  
    contextConfigLocation
    classpath:spring-mvc.xml
  
  1

  
    DispatcherServlet
    /

3. 创建controller类，跳转到jsp视图页面

对着src/main/java右键，有个包com.tang,再新建包名controller，新建c class文件

package com.tang.controller;


import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class UserController {

    @RequestMapping("/quick")
    public String save(){
        System.out.println("Controller save running...");
        return "success.jsp";
    }
}

对着webapp右键new ，jsp 命名为success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    Title


Success!

4. 配置文件,组件扫描

对着src/main/resources右键，new== xml==spring config 命名为spring-mvc.xml，加入以下代码

5. 测试代码

http://localhost:8080/spring_mvc/quick 出现success即成功

二、SpringMVC组件解析 2.1 SpringMVC的执行流程

用户发送请求至前端控制器DispatcherServlet。
DispatcherServlet收到请求调用HandlerMapping处理器映射器。
处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
DispatcherServlet调用HandlerAdapter处理器适配器。
HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。
Controller执行完成返回ModelAndView.
HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet.
DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
ViewReslover解析后返回具体View。
DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中). DispatcherServlet响应用户。

2.2 SpringMVC注解解析

@RequestMapping(value = "/quick",method = RequestMethod.GET,params ={"username"})

作用:

用于建立请求URL和处理请求方法之间的对应关系位置，可以写在类上，也可以写在方法上，代表localhost:8080/后面的访问路径

属性：

value:用于指定请求的URL。它和path属性的作用是一样的
method:用于指定请求的方式
params:用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的key和value必须和配置的一模一样

配置视图解析器

三、SpringMVC的数据响应方式 3.1 页面跳转 3.1.1 直接返回字符串

此种方式会将返回的字符串与视图解析器的前后缀拼接后跳转。

@RequestMapping("/quick")     // 没有@ResponseBody注解，则说明进行url拼接
    public String save(){
        return "index";
    }

转发资源地址：/WEB-INF/views/index.jsp

3.1.2 通过ModelAndView对象返回

 @RequestMapping(value = "/quick")
    public ModelAndView save(){
        ModelAndView modelAndView=new ModelAndView();
        //设置模型数据
        modelAndView.addObject("username","itcast");
        //设置视图名称
        modelAndView.setViewName("success");
        return modelAndView;
    }

3.2 回写数据（看1和4） 3.2.1 直接返回字符串

两段代码效果一样

 @RequestMapping(value = "/quick")
    public void save2(HttpServletResponse response)throws Exception{
        response.getWriter().println("hello");
    }
	
    ================================================================================
      @RequestMapping(value = "/quick")
    @ResponseBody //有这个注解，告知MVC框架，不进行视图跳转，直接进行数据响应
    public String save2()throws Exception{
        return "hello";
    }

3.2.2 手动回写json格式字符串（不推荐）

使用json的转换工具将对象转换成json字符串再返回


      com.fasterxml.jackson.core
      jackson-core
      2.9.0
    
    
      com.fasterxml.jackson.core
      jackson-databind
      2.9.0
    
    
      com.fasterxml.jackson.core
      jackson-annotations
      2.9.0

	 @RequestMapping(value = "/quick")
    @ResponseBody
    public String save2()throws Exception{
        User user=new User();
        user.setName("lisi");
        user.setAge(30);
        //使用json的转换工具
        ObjectMapper objectMapper=new ObjectMapper();
        String json=objectMapper.writevalueAsString(user);
        return json;
    }

3.2.3 期望SpringMVC自动转换成json格式的字符串（不推荐）

SpringMVC.xml 添加以下代码，这是配置处理器映射器

3.2.4 返回对象或集合，用注解自动转成json（推荐）

四、SpringMVC的请求 4.1 获得请求参数

客户端请求参数的格式是：name=value&name=value… …

服务器端要获得请求的参数，有时还需要进行数据的封装，SpringMVC可以接收如下类型的参数：

基本类型参数
POJO类型参数
数组类型参数
集合类型参数

4.1.1 获得基本类型参数

Controller中的业务方法的参数名称要与请求参数的name一致，参数值会自动匹配映射

	@RequestMapping(value = "/quick")
    @ResponseBody
    public void save2(String username,int age)throws Exception{
        System.out.println(username);
        System.out.println(age);
    }
    
    访问http://localhost:8080/spring_mvc/quick?username=zhangsan&&age=12 
    控制台出现zhangsan，12 即可

4.1.2 获得POJO类型参数

Controller中的业务方法的POJO参数名称要与请求参数的name一致，参数值会自动匹配映射

	public class User{
		private String username;
		private int age;
		getter/setter
	}
	
	@RequestMapping(value = "/quick")
    @ResponseBody
    public void save2(User user)throws Exception{
        System.out.println(user);
    }

  访问http://localhost:8080/spring_mvc/quick?username=zhangsan&&age=12 
    控制台出现zhangsan，12 即可

4.1.3 获得数组类型参数

	@RequestMapping(value = "/quick")
    @ResponseBody
    public void save2(String[] strs)throws Exception{
        System.out.println(Arrays.asList(strs));
    }

  访问http://localhost:8080/spring_mvc/quick?strs=111&strs=222&strs=333 
    控制台出现[111,222,333] 即可

4.1.4 获得集合类型参数

获得集合参数时，要将集合参数包装到一个POJO中才可以。（不推荐）
当使用ajax提交时，可以指定contentType为json形式，那么在方法参数位置使用@RequestBody可以直接接收集合数据而无需使用POJO进行包装

4.2 MVC获取数据细节 4.2.1 静态资源访问的开启

在spring-mvc.xml文件下加入

4.2.2 请求数据乱码问题

当post请求时，数据会出现乱码，我们可以设置一个过滤器来进行编码的过滤

在web.xml添加代码

  
    CharacterEncodingFilter
    org.springframework.web.filter.CharacterEncodingFilter
    
      encoding
      UTF-8
    
  
  
    CharacterEncodingFilter
    /*

4.2.3 参数绑定注解@requestParam

当请求的参数名称与Controller的业务方法参数名称不一致时，就需要通过@requestParam注解显示的绑定

value：与请求参数名称
required：此在指定的请求参数是否必须包括，默认是true，提交时如果没有此参数则报错
defaultValue：当没有指定请求参数时，则使用指定的默认值赋值

 @RequestMapping(value = "/quick")
    @ResponseBody
    public void save2(@RequestParam(value = "name",required = false,defaultValue = "itcast") String username)throws Exception{
        System.out.println(username);
  }//访问name和访问username就一样了，不加这个，访问name是出错的

4.2.4 获得Restful风格的参数

Restful是一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。主要用于客户端和服务器交互类的软件，基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存机制等。

Restful风格的请求是使用“url+请求方式”表示一次请求目的的，HTTP协议里面四个表示操作方式的动词如下：

GET:用于获取资源
POST：用于新建资源
PUT：用于更新资源
DELETe：用于删除资源

@RequestMapping(value = "/quick/{username}")
@ResponseBody
public void save2(@PathVariable(value = "username") String username)throws Exception{
    System.out.println(username);
}
//访问http://localhost:8080/spring_mvc/quick/zhangsan，控制台输出zhangsan

4.2.5 自定义类型转换器

SpringMVC默认已经提供了一些常用的类型转换器，例如客户端提交的字符串转换成int型进行参数设置。但是不是所有的数据类型都提供了转换器，没有提供的就需要自定义转换器，例如:日期类型的数据就需要自定义转换器。

自定义类型转换器的开发步骤：

（1）定义转换器类实现Converter接口

public class DateConverter implements Converter {

    @Override
    public Date convert(String dataStr) {
        SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd");
        Date date=null;
        try{
            date=format.parse(dataStr);
        }catch (ParseException e){
            e.printStackTrace();
        }
        return date;
    }
}

（2）在springmvc配置文件中声明转换器

（3）在中引用转换器

4.2.6 获得Servlet相关API

SpringMVC支持使用原始ServletAPI对象作为控制器方法的参数进行注入，常用的对象如下：

HttpServletRequest//HttpServletResponse//HttpSession

@RequestMapping(value = "/quick")
@ResponseBody
public void save2(HttpServletRequest request, HttpServletResponse response, HttpSession session)throws Exception{
    System.out.println(request);
    System.out.println(response);
    System.out.println(session);
}

4.2.7 获得请求头

（1）@RequestHeader

获得请求头信息。

value:请求头的名称
required：是否必须携带此请求头

@RequestMapping(value = "/quick")
@ResponseBody
public void save2(@RequestHeader(value = "User-Agent",required = false)String user_agent)throws Exception{
    System.out.println(user_agent);
}

（2）@cookievalue

获得指定cookie的值。

value:请求cookie的名称
required：是否必须携带此cookie

@RequestMapping(value = "/quick")
@ResponseBody
public void save2(@cookievalue(value = "JSESSIONID")String jsessionId) throws IOException {
    System.out.println(jsessionId);
}

4.3 文件上传（未成功）

这边举例单文件上传，多文件上传，用数组即可

对着webapp 新建upload.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    Title


    
        名称

        文件

（1）pom.xml


  commons-fileupload
  commons-fileupload
  1.4


  commons-io
  commons-io
  2.6

(2)springmvc.xml

(3)编写上传代码

@RequestMapping(value = "/quick")
@ResponseBody
public void save2(String username, MultipartFile uploadFile) throws IOException {
    System.out.println(username);

    //获得上传文件的名称
    String originalFilename= uploadFile.getOriginalFilename();
   uploadFile.transferTo(new File("D:\upload\"+originalFilename));
}

五、SpringMVC拦截器

Interceptor,类似于Filter，用于对处理器进行预处理和后处理

（1）创建拦截器类实现HandlerInterceptor接口

package com.tang.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyInterceptor1 implements HandlerInterceptor {
    //在目标方法执行之前，执行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle...");
        return true;
    }
    //在目标方法执行之后，视图对象返回之前执行
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle...");

    }
    //在整个流程都执行完毕后，执行这个方法
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion...");
    }
}

（2）配置拦截器，springmvc.xml

（3）测试拦截器的拦截效果

六、SpringMVC异常处理

使用SpringMVC提供的简单异常处理器SimpleMappingExceptionResolver
实现Spring的异常处理接口HandlerExceptionResolver自定义自己的异常处理器
目的，不要让用户看到404，报错一大堆英文字母，把页面改成，网络繁忙，请稍后访问，更友好一些

6.1 简单异常处理器SimpleMappingExceptionResolver

异常与视图的映射配置，springmvc.xml,新建error.jsp,随便写个错误页面

6.2 自定义异常处理器

（1）创建异常处理器类实现HandlerExceptionResolver接口

（2）配置异常处理器

（3）编写异常页面

（4）测试异常跳转

Mybatis 一、快速入门 1.1添加Mybatis坐标,pom.xml


  org.springframework
  spring-context
  5.0.5.RELEASE


  junit
  junit
  4.11
  test


  javax.servlet
  javax.servlet-api
  3.1.0



  javax.servlet.jsp
  javax.servlet.jsp-api
  2.2.1





  mysql
  mysql-connector-java
  5.1.47


  org.mybatis
  mybatis
  3.4.6


  log4j
  log4j
  1.2.17





  org.springframework
  spring-web
  5.0.5.RELEASE


  org.springframework
  spring-webmvc
  5.0.5.RELEASE


  junit
  junit
  4.12
  test

1.2 创建user数据表

CREATE TABLE `user`(
	id INT,
	username VARCHAr(20), 
	`password` VARCHAr(20)
)CHARSET=utf8;


INSERT INTO `user`(id,username,`password`) VALUES (1,'zhangsan','123');
INSERT INTO `user`(id,username,`password`) VALUES (2,'lisi','123');
INSERT INTO `user`(id,username,`password`) VALUES (3,'wangwu','123');
INSERT INTO `user`(id,username,`password`) VALUES (4,'zhaoliu','123');
INSERT INTO `user`(id,username,`password`) VALUES (5,'tianqi','123');

1.3 编写User实体类

//com.tang 包下创建domain包，新建User  class文件
package com.tang.domain;

public class User {
    private int id;
    private String username;
    private String password;

    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 getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

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

1.4 编写映射文件UserMapper.xml

//在src/main/resources下新建Directory，命名为com/tang/mapper，新建File，命名为UserMapper.xml 





    
        select * from user

 //MyBatisTest   替换以下代码

package com.tang.test;

import com.tang.domain.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.*;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.util.List;

public class MyBatisTest {
    @Test
    public void test1() throws IOException {
        User user=new User();
        user.setId(6);
        user.setUsername("tom");
        user.setPassword("abc");
        InputStream resourceAsStream=Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession=sqlSessionFactory.openSession();
        sqlSession.insert("userMapper.save",user);
        sqlSession.commit();
        sqlSession.close();

    }
}
//点击15行的小箭头，控制台打印空白，去看数据库，新增了第六行，说明成功

2.2 修改操作

//UserMapper.xml   替换以下代码




    
    
       update user set username=#{username},password=#{password} where id=#{id}
    

    
        insert into user value(#{id},#{username},#{password})
    


    
        select * from user
    


=======================================================================================

 //MyBatisTest   替换以下代码

package com.tang.test;

import com.tang.domain.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.*;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.util.List;

public class MyBatisTest {
    @Test
    public void test1() throws IOException {

        InputStream resourceAsStream=Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession=sqlSessionFactory.openSession();
        sqlSession.delete("userMapper.delete",6);
        sqlSession.commit();
        sqlSession.close();

    }
}

//点击15行的小箭头，控制台打印空白，去看数据库，id=6的已删除，表示成功

2.4 查找操作

在快速入门，已经演示过了

三、Mybatis的dao层实现，接口代理实现

UserMapper.xml






    
    
        select * from user
    


=====================================================================================
sqlMapConfig.xml




    
        
    

    
        
            
            
                
                
                
                
            
        
    

    
        
    



=====================================================================================
//UserMapper
        
  package com.tang.dao;

import com.tang.domain.User;

import java.io.IOException;
import java.util.List;

public interface UserMapper {
    public List findAll() throws IOException;
    public User findById(int id);
}
=====================================================================================

 //ServiceDemo   
    
 package com.tang.service;

import com.tang.dao.UserMapper;
import com.tang.domain.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.*;
import java.io.*;
import java.util.List;


public class ServiceDemo {


    public static void main(String[] args) throws IOException {
        InputStream resourceAsStream=Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession=sqlSessionFactory.openSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        List all=mapper.findAll();
        System.out.println(all);

        User user=mapper.findById(1);
        System.out.println(user);
    }
}
//点击14行，绿色箭头，出现两行语句即可

四、动态SQL

select * from user where id=#{id} and username=#{username} 如果id为null，则sql查找为id=null的，找不到，则返回空，所以为解决这个问题，出现了动态SQL

4.1 if语句


    select * from user 
    
    
        and id=#{id}
    
    
        and username=#{username}
    
    
        and password=#{password}

4.2 foreach语句

原句：select * from user where id in(1,2,3)


    select * from user 
    
        
            #{id}

五、MyBatis核心配置文件 5.1 常用标签

properties标签：加载外部的properties文件
typeAliases标签：设置类型别名
environments标签：数据源环境配置标签
typeHandlers标签：配置自定义类型处理器
plugins标签：配置MyBatis的插件

5.2 pagehelper分页（未测试，弹幕说有错）

（1）导入坐标 pom.xml


  com.github.pagehelper
  pagehelper
  3.7.5


  com.github.jsqlparser
  jsqlparser
  0.9.1

（2）配置pagehelper插件,sqlMapConfig.xml

（3）测试分页数据获取，功能强大

		PageHelper.startPage(1,3); //当前页+每页显示的条数

        PageInfo pageInfo=new PageInfo(userList);
        System.out.println("当前页："+pageInfo.getPageNum());
        System.out.println("每页显示条数："+pageInfo.getPageSize());
        System.out.println("总条数："+pageInfo.getTotal());
        System.out.println("总页数："+pageInfo.getPages());
        System.out.println("上一页："+pageInfo.getPrePage());
        System.out.println("下一页："+pageInfo.getNextPage());
        System.out.println("是否是第一页："+pageInfo.isIsFirstPage());
        System.out.println("是否是最后一页："+pageInfo.isIsLastPage());

六、Mybatis注解开发 6.1 CRUD

@Insert

@Update

@Delete

@Select

6.2 多表查询

一对一，一对多，多对多

AOP 一、Spring的AOP简介 1.1 什么是AOP？

AOP，是面向切面编程，是通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

1.2 AOP的作用及其优势？

作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强
优势：减少重复代码，提高开发效率，并且便于维护

1.3 基于jdk的动态代理(后期会封装)

src/main/java/com.tang 新建包proxy.jdk

//在包下建立接口，TargetInterface
package com.tang.proxy.jdk;

public interface TargetInterface {
    public void save();
}

//在包下建立Target.class文件
package com.tang.proxy.jdk;

public class Target implements TargetInterface{
    @Override
    public void save() {
        System.out.println("save running...");
    }
}

//在包下建立Advice.class文件
package com.tang.proxy.jdk;

public class Advice {
    public void before(){
        System.out.println("前置增强...");
    }
    public void afterReturning(){
        System.out.println("后置增强...");
    }
}

//在包下建立ProxyTest.class文件
package com.tang.proxy.jdk;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyTest {
    public static void main(String[] args) {

        final Target target=new Target();
        Advice advice=new Advice();

        TargetInterface proxy=(TargetInterface)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                advice.before();

                Object invoke=method.invoke(target,args);
                advice.afterReturning();
                return invoke;
            }
        });
        proxy.save();
    }
}

//点击第8行，绿色箭头，控制台输出前置增强...，save running...，后置增强...，说明成功

1.4 基于cglib的动态代理(后期会封装)


  org.springframework
  spring-context
  5.0.5.RELEASE

src/main/java/com.tang 新建包proxy.cglib

//在包下建立Target.class文件
package com.tang.proxy.cglib;
public class Target  {
    public void save() {
        System.out.println("save running...");
    }
}

//在包下建立Advice.class文件
package com.tang.proxy.cglib;

public class Advice {
    public void before(){
        System.out.println("前置增强...");
    }
    public void afterReturning(){
        System.out.println("后置增强...");
    }
}

//在包下建立ProxyTest.class文件
package com.tang.proxy.cglib;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyTest {
    public static void main(String[] args) {

        final Target target=new Target();
        final Advice advice=new Advice();

        Enhancer enhancer=new Enhancer();
        enhancer.setSuperclass(Target.class);
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                advice.before();
                Object invoke=method.invoke(target,args);
                advice.afterReturning();
                return invoke;
            }
        });
        Target proxy=(Target)enhancer.create();
        proxy.save();
    }
}

//点击第12行，绿色箭头，控制台输出前置增强...，save running...，后置增强...，说明成功

1.5 AOP相关概念

Target(目标对象)∶代理的目标对象
Proxy(代理):一个类被AOP织入增强后，就产生一个结果代理类
Joinpoint(连接点)∶所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点
Pointcut(切入点)∶所谓切入点是指我们要对哪些Joinpoint进行拦截的定义
Advice (通知/增强)︰所谓通知是指拦截到Joinpoint之后所要做的事情就是通知
Aspect(切面)︰是切入点和通知(引介)的结合
Weaving (织入)︰是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入

二、基于XML的AOP开发 2.1 快速入门(未成功)

（1）导入AOP相关坐标，pom.xml


  org.springframework
  spring-test
  5.0.5.RELEASE


  org.aspectj
  aspectjweaver
  1.8.4


  junit
  junit
  4.12
  test

 
      org.springframework
      spring-test
      5.0.5.RELEASE

（2）创建目标接口和目标类（内部有切点）

在src/main/java,在com.tang下，新建package，命名为aop

//在包下建立接口，TargetInterface
package com.tang.aop;

public interface TargetInterface {
    public void save();
}

//在包下建立Target.class文件
package com.tang.aop;


public class Target implements TargetInterface{
    @Override
    public void save() {
        System.out.println("save running...");
    }
}

（3）创建切面类（内部有增强方法）

//在包下建立MyAspect.class文件
package com.tang.aop;

public class MyAspect {
    public void before(){
        System.out.println("前置增强....");
    }
}

（4）将目标类和切面类的对象创建权交给Spring，第四和第五步，都在xml文件里

（5）在applicationContext.xml中配置织入关系

（6）测试代码

//test/java/com.tang  右键新建test.AopTest
package com.tang.test;

import com.tang.proxy.jdk.TargetInterface;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Autowired
    private TargetInterface target;

    @Test
    public void test1(){
        target.save();
    }
} //控制台输出 save running

2.2 切点表达式

表达式语法：  execution([修饰符]返回值类型 包名.类名.方法名(参数))

访问修饰符可以省略
返回值类型、包名、类名、方法名可以使用*代表任意
包名与类名之间一个点.代表当前包下的类，两个点…代表当前包及其子包下的类
参数列表可以使用两个点… 表示任意个数，任意类型的参数列表

三、基于注解的AOP开发

（1）@Aspect 标注当前类是一个切面类

（2）@通知注解标注通知方法

（3）在配置文件中配置aop自动代理，aop:aspectj-autoproxy

通知注解类型：

前置通知	@Before	指定增强的方法在切入点方法之前执行
后置通知	@AfterReturning	指定增强的方法在切入点方法之后执行
环绕通知	@Around	指定增强的方法在切入点方法之前和之后都执行
异常抛出通知	@AfterThrowing	指定增强的方法在出现异常时执行
最终通知	@After	指定增强的方法是否有异常都会执行

Spring JdbcTemplate

他是Spring框架中提供的一个对象，是对原始繁琐的JdbcAPI对象的简单封装。Spring框架为我们提供了很多的操作模板类。

一、快速入门

（1）导入坐标,pom.xml


  org.springframework
  spring-jdbc
  5.0.5.RELEASE


  org.springframework
  spring-tx
  5.0.5.RELEASE



      mysql
      mysql-connector-java
      5.1.47
    

    
      com.alibaba
      druid
      1.1.21
    

    
      c3p0
      c3p0
      0.9.1.2

（2）创建数据库表和实体

#在company.db下创建account表

CREATE TABLE account(
	NAME VARCHAr(20), 
	money INT
	
)CHARSET=utf8;

//对着test/java右键新建class文件    命名为com.tang.domain.Account

package com.tang.domain;

public class Account {
    private String name;
    private double money;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "name='" + name + ''' +
                ", money=" + money +
                '}';
    }
}

（3）创建JdbcTemplate对象,执行数据库操作

//对着test/java右键新建class文件    命名为com.tang.test.JdbcTemplateTest
package com.tang.test;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;

import java.beans.PropertyVetoException;

public class JdbcTemplateTest {
    @Test
    public void test1() throws PropertyVetoException {
        //创建数据源对象，C3P0
        ComboPooledDataSource dataSource=new ComboPooledDataSource();
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/companydb");
        dataSource.setUser("root");
        dataSource.setPassword("123456");

        JdbcTemplate jdbcTemplate=new JdbcTemplate();
        //设置数据源对象，知道数据库在哪
        jdbcTemplate.setDataSource(dataSource);
        //执行操作
        int row=jdbcTemplate.update("insert into account values(?,?)","tom",5000);
        System.out.println(row);
    }
}
//点击左侧绿色箭头，run，控制台返回1，数据库插入成功

二、Spring产生JdbcTemplate对象 2.1 不用配置文件

我们可以将JdbcTemplate的创建权交给Spring，将数据源DataSource的创建权也交给Spring，在Spring容器内部将数据源DataSource注入到JdbcTemplate模板对象中，配置如下：

//对着test-resources，右键xml-Spring config  命名为applicationContext

//对着test/java右键新建class文件    命名为com.tang.test.JdbcTemplateTest
package com.tang.test;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

import java.beans.PropertyVetoException;

public class JdbcTemplateTest {
    @Test
    public void test1() throws PropertyVetoException {
        ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
        JdbcTemplate jdbcTemplate=app.getBean(JdbcTemplate.class);
        int row=jdbcTemplate.update("insert into account values(?,?)","zhangsan",5000);
        System.out.println(row);

    }
}

2.2 用配置文件（推荐）

// src-test-resources  下新建 File 命名为jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/companydb?useUnicode=true&characterEncoding=utf-8&useSSL=false
jdbc.username=root
jdbc.password=123456
======================================================================================
  
    // 对着test-resources，右键xml-Spring config  命名为applicationContext，修改applicationContext.xml  




    
    
    
        
        
        
        
    
    
    
        

    

  
 ====================================================================================== 
 //对着test/java右键新建class文件    命名为com.tang.test.JdbcTemplateTest
package com.tang.test;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

import java.beans.PropertyVetoException;

public class JdbcTemplateTest {
    @Test
    public void test1() throws PropertyVetoException {
        ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
        JdbcTemplate jdbcTemplate=app.getBean(JdbcTemplate.class);
        int row=jdbcTemplate.update("insert into account values(?,?)","lisi",5000);
        System.out.println(row);

    }
}

三、增删改查

在test/java/com.tang/test包下，新建JdbcTemplateCRUDTest.class文件

导入junit依赖


  org.springframework
  spring-test
  5.0.5.RELEASE

   
      junit
      junit
      4.11
      test

增删改查

package com.tang.test;

import com.tang.domain.Account;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JdbcTemplateCRUDTest  {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Test
    public void testUpdate(){
        jdbcTemplate.update("update account set money=? where name=?",10000,"tom");
    }
    @Test
    public void testDelete(){
        jdbcTemplate.update("delete from account where name=?","tom");
    }
    @Test
    public void testQueryAll(){
        List accountList=jdbcTemplate.query("select * from account",new BeanPropertyRowMapper(Account.class));
        System.out.println(accountList);
    }
    @Test
    public void testQueryOne(){
       Account account= jdbcTemplate.queryForObject("select * from account where name=?",new BeanPropertyRowMapper(Account.class),"tom");
        System.out.println(account);
    }

}

SSM学习笔记

Java相关栏目本月热门文章