SSM

Spring

spring配置数据源

1.数据源开发步骤

• 导入数据源jar
• 创建数据源对象
• 设置数据源的基本连接数据
• 使用数据源获取连接资源和归还资源

2.资源

<dependency>
  <groupId>mysqlgroupId>
  <artifactId>mysql-connector-javaartifactId>
  <version>8.0.28version>
dependency>

<dependency>
  <groupId>c3p0groupId>
  <artifactId>c3p0artifactId>
  <version>0.9.1.2version>
dependency>
<dependency>
  <groupId>com.alibabagroupId>
  <artifactId>druidartifactId>
  <version>1.1.12version>
dependency>
<dependency>
  <groupId>junitgroupId>
  <artifactId>junitartifactId>
  <version>4.11version>
  <scope>testscope>
dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.手动创建数据源

//jdbc.driver=com.mysql.cj.jdbc.Driver
//jdbc.url=jdbc:mysql://localhost:3306/mysql
//jdbc.username=root
//jdbc.password=123456
public class DataSourceTest {
    // 手动创建c3p0数据源
    @Test
    public void test1() throws PropertyVetoException, SQLException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/mysql");
        dataSource.setUser("root");
        dataSource.setPassword("123456");
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }

    // 手动创建druid数据源
    @Test
    public void test2() throws SQLException {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/mysql");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }

    // 读取配置文件
    @Test
    public void test3() throws PropertyVetoException, SQLException {
        // 读取配置
        ResourceBundle rb = ResourceBundle.getBundle("jdbc");
        //
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass(rb.getString("jdbc.driver"));
        dataSource.setJdbcUrl(rb.getString("jdbc.url"));
        dataSource.setUser(rb.getString("jdbc.username"));
        dataSource.setPassword(rb.getString("jdbc.password"));
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

3.spring配置数据源

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <context:property-placeholder location="jdbc.properties" />
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    bean>
beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14

###注解开发

####spring原始注解

开启组件扫描

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

spring新注解

例子：xml配置==配置类

<context:property-placeholder location="jdbc.properties" />
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${jdbc.driver}"/>
    <property name="jdbcUrl" value="${jdbc.url}"/>
    <property name="user" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>

<context:component-scan base-package="com.zhongcode" />
1
2
3
4
5
6
7
8
9

// spring 配置类
@Configuration
@ComponentScan("com.zhongcode")
@PropertySource("classpath:jdbc.properties")
public class SpringConfiguration {

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

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

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

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

    @Bean("dataSource")
    public DataSource dataSource() throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass(driver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

Spring集成Junit

Spring集成Junit步骤
1.导入spring集成Junit的坐标
2.使用@Runwith注解替换原来的运行期
3.使用@ContextConfiguration指定配置文件或配置类
4.使用@Autowired注入需要测试的对象
5.创建测试方法进行测试

代码测试：

@RunWith(SpringJUnit4ClassRunner.class)
// xml配置模式
@ContextConfiguration("classpath:applicationContext.xml")
// 配置类模式
//@ContextConfiguration(classes = SpringConfiguration.class)
public class SpringJunitTest {
    @Autowired
    private UserService userService;
    @Test
    public void test1(){
        userService.print();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

SpringMVC

SpringMVC基础

1.导入SpringMVC的jar包

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-testartifactId>
dependency>
<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-contextartifactId>
dependency>
<dependency>
    <groupId>javax.servletgroupId>
    <artifactId>javax.servlet-apiartifactId>
dependency>
<dependency>
    <groupId>javax.servlet.jspgroupId>
    <artifactId>javax.servlet.jsp-apiartifactId>
dependency>
<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-webartifactId>
dependency>
<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-webmvcartifactId>
dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2.配置SpringMVC核心控制器DispathcerServlet

web.xml

    <servlet>
        <servlet-name>DispatcherServletservlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
        <init-param>
            <param-name>contextConfigLocationparam-name>
            <param-value>classpath:spring-mvc.xmlparam-value>
        init-param>
        <load-on-startup>1load-on-startup>
    servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServletservlet-name>
        <url-pattern>/*url-pattern>
    servlet-mapping>
    
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
    listener>

    <context-param>
        <param-name>contextConfigLocationparam-name>
        <param-value>classpath:applicationContext.xmlparam-value>
    context-param>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3.创建SpringMVC核心文件spring-mvc.xml

<context:component-scan base-package="com.zhongcode.controller"/>
1
2

4.客户端发请求（测试）

SpringMVC 注解

• @RequestMapping
  作用：用于建立请求URL 和处理请求方法之间的对应关系
  位置：
  • 类上，请求URL 的第一级访问目录。此处不写的话，就相当于应用的根目录
  • 方法上，请求URL 的第二级访问目录，与类上的使用@ReqquestMapping标注的一级目录一起组成访问虚拟路径
• 属性：
  • value：用于指定请求的URL。它和path属性的作用是一样的
  • method：用于指定请求的方式
  • params：用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的key和value必须和配置的一模一样

SpringMVC 数据响应

页面跳转

• 转发

• 重定向redirect

• 返回视图

  @RequestMapping("/")
  public ModelAndView test1() {
      ModelAndView modelAndView = new ModelAndView();
      modelAndView.setViewName("index");
      return modelAndView;
  }
  1
  2
  3
  4
  5
  6

回写数据

• 直接写

  @RequestMapping("/3")
  public void test3(HttpServletRequest request, HttpServletResponse response) throws IOException {
      response.setCharacterEncoding("UTF-8");
      response.setHeader("Content-type","text/html;charset=UTF-8");
      response.getWriter().write("访问成功");
  }
  1
  2
  3
  4
  5
  6

• @ResponseBody

  @RequestMapping("/4")
  @ResponseBody
  public String test4(){
      return "访问成功4";
  }
  1
  2
  3
  4
  5

• 返回对象和集合

  需要配置解析器（两种方式）

  <bean id="requestMappingHandlerAdapter"
        class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
      <property name="messageConverters">
          <list>
              <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter" />
          list>
      property>
  bean>
  1
  2
  3
  4
  5
  6
  7
  8

  <mvc:annotation-driven/>
  1

  使用====默认底层就会集成jackson进行对象或集合的json格式字符串的转换。

SpringMVC 数据获取

基本类型参数

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

POJO参数参数

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

数组类型参数

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

集合类型参数

• 获得集合参数时，要将集合参数包装到一个POJO中才可以。

• 当使用ajax提交时，可以指定ontentType为json形式，那么在方法参数位置使用==@RequestBody==可以直接接收集合数据而无需使用POJO进行包装。

配置全局乱码过滤器

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

    <filter>
        <filter-name>characterEncodingFilterfilter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
        <init-param>
            <param-name>encodingparam-name>
            <param-value>UTF-8param-value>
        init-param>
    filter>
    <filter-mapping>
        <filter-name>characterEncodingFilterfilter-name>
        <url-pattern>/*url-pattern>
    filter-mapping>
1
2
3
4
5
6
7
8
9
10
11
12
13

参数绑定注解@requestParam

注解@RequestParam还有如下参数可以使用:

• value:与请求参数名称

• required:此在指定的请求参数是否必须包括，默认是true，提交时如果没有此参数则报错

• defaultValue:当没有指定请求参数时，则使用指定的默认值赋值

自定义类型转换器

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

• 定义转换器类实现Converter接口
• 在配置文件中声明转换器
• 在中引用转换器

public class DateConverter implements Converter {
    @Override
    public Date convert(String source) {
        // 将日期字符串转成日期对象返回
        SimpleDateFormat format = new SimpleDateFormat("yyy-MM-dd");
        Date date = null;
        try {
            date = format.parse(source);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

    

    
        
            
        
    

1
2
3
4
5
6
7
8
9

获得请求头@RequestHeader

使用@RequestHeader可以获得请求头信息，相当于web阶段学习的request.getHeader(name)

@RequestHeader注解的属性如下:

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

文件上传(多文件上传)

1.构建表单

注意：enctype=“multipart/form-data”

    

    

    

    

1
2
3
4
5
6

2.添加上传IO的jar包

<dependency>
    <groupId>commons-iogroupId>
    <artifactId>commons-ioartifactId>
dependency>
<dependency>
    <groupId>commons-fileuploadgroupId>
    <artifactId>commons-fileuploadartifactId>
dependency>
1
2
3
4
5
6
7
8
9

3.配置SpringMVC处理器

注意解析器id不能修改

<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name="maxUploadSize" value="5242800"/>
    <property name="maxUploadSizePerFile" value="5242800"/>
    <property name="defaultEncoding" value="UTF-8"/>
bean>
1
2
3
4
5
6

4.上传控制器

MultipartFile名称要与表单name一样

@RequestMapping("/uploadFile")
@ResponseBody
public String upload(@RequestParam("file") MultipartFile[] file) throws IOException {
    for(MultipartFile multipartFile:file){
        String filename = multipartFile.getOriginalFilename();
        multipartFile.transferTo(new File("E:/upload_temp/"+filename));
    }
    return "ok";
}
1
2
3
4
5
6
7
8
9

SpringMVC拦截器

Spring MVC的拦截器类似于Servlet开发中的过滤器Filter，用于对处理器进行预处理和后处理,

拦截器入门

1.创建拦截器类实现HandlerInterceptor的接口

public class MyInterceptor implements HandlerInterceptor {
    /**
     * 在目标方法执行前执行
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle");
        return true;
    }

    /**
     * 目标方法执行之后，视图返回之前执行
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle");
    }

    /**
     * 在流程执行完毕之后执行
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

2.配置拦截器（spring-mvc.xml）

<mvc:interceptors>
    <mvc:interceptor>
        
        <mvc:mapping path="/**"/>
        <bean class="com.zhongcode.interceptor.AInterceptor"/>
    mvc:interceptor>
mvc:interceptors>
1
2
3
4
5
6
7
8

方法详细

SpringMVC异常处理

使用SpringMVC简单异常处理器

SimpleMappingExceptionResolver

    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        
        <property name="defaultErrorView" value="404"/>
        <property name="exceptionMappings">
            <map>
  				
                <entry key="com.zhongcode.exception.MyException" value="500"/>
            map>
        property>
    bean>
1
2
3
4
5
6
7
8
9
10
11

自定义处理器

编写异常处理类实现接口HandlerExceptionResolver

将自己实现的处理类加入容器中

spring aop

常用的动态代理技术

• JDK代理:基于接口的动态代理技术
• cglib代理:基于父类的动态代理技术

JDK代理

public static void main(String[] args) {
    // 目标对象
    final Target target = new Target();
    // 增强对象
    final Advice advice = new Advice();
    TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
            // 目标对象的类加载器
            target.getClass().getClassLoader(),
            // 目标对象相同的接口组
            target.getClass().getInterfaces(),
            new InvocationHandler() {
                // 调用代理对象的任何方法 实质执行都是invoke
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    advice.before();
                    //执行目标方法
                    method.invoke(target, args);
                    advice.afterReturning();
                    return null;
                }
            }
    );
    proxy.save();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

cglib代理

public static void main(String[] args) {
    // 目标对象
    final Target target = new Target();
    // 增强对象
    final Advice advice = new Advice();
    // 基于cglie 动态
    // 1.创建增强器
    Enhancer enhancer = new Enhancer();
    // 2.设置父类
    enhancer.setSuperclass(Target.class);
    // 3.设置回调
    enhancer.setCallback(new MethodInterceptor() {
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            advice.before();
            Object invoke = method.invoke(target, args);
            advice.afterReturning();
            return invoke;
        }
    });
    // 4.创建代理对象
    Target o = (Target) enhancer.create();
    o.save();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

概念

Spring的AOP实现底层就是对上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。
在正式讲解AOP的操作之前，我们必须理解AOP的相关术语，常用的术语如下:

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

XML 配置AOP 详解

切点表达式的写法

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

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

通知的类型

语法

aop:通知类型>
1

<aop:config>
    
    <aop:aspect ref="myAspect">
        <aop:before method="before" pointcut="execution(* com.zhongcode.aop.Target.save())"/>
    aop:aspect>
aop:config>
1
2
3
4
5
6

切面表达式可以抽取

当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用pointcut-ref 属性代替pointcut 属性来引用抽取后的切点表达式。

注解配置

注解aop开发步骤

• 使用@Aspect标注切面类
• 使用@通知注解标注通知方法
• 在配置文件中配置aop自动代理通知注解类型