SSM框架学习笔记

最新推荐文章于 2024-06-11 07:55:51 发布

卑微小钟

最新推荐文章于 2024-06-11 07:55:51 发布

阅读量1.5w

点赞数 2

分类专栏： java 后端 spring 文章标签：学习 java spring tomcat maven

本文链接：https://blog.csdn.net/zhongjianboy/article/details/126342619

版权

java 同时被 3 个专栏收录

46 篇文章 2 订阅

订阅专栏

后端

34 篇文章 0 订阅

订阅专栏

spring

13 篇文章 0 订阅

订阅专栏

SSM

Spring

spring配置数据源

1.数据源开发步骤

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

2.资源

<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>8.0.28</version>
</dependency>
<!-- https://mvnrepository.com/artifact/c3p0/c3p0 -->
<dependency>
  <groupId>c3p0</groupId>
  <artifactId>c3p0</artifactId>
  <version>0.9.1.2</version>
</dependency>
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>
  <version>1.1.12</version>
</dependency>
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.11</version>
  <scope>test</scope>
</dependency>

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();
    }

3.spring配置数据源

<?xml version="1.0" encoding="UTF-8"?>
<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>

###注解开发

####spring原始注解

开启组件扫描

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

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

spring新注解

注解	解释
@Configuration	用于指定当前类是一个Spring 配置类，当创建容器时会从该类上加载注解
@ComponentScan	用于指定Spring 在初始化容器时要扫描的包。作用和在Spring 的xml 配置文件中的 <context:component-scan base-package=“com.itheima”/>一样
@Bean	使用在方法上，标注将该方法的返回值存储到Spring 容器中
@PropertySource	用于加载.properties 文件中的配置
@Import	用于导入其他配置类

例子：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" />

// 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;
    }
}

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();
    }
}

SpringMVC

SpringMVC基础

1.导入SpringMVC的jar包

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
</dependency>
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>javax.servlet.jsp-api</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
</dependency>

2.配置SpringMVC核心控制器DispathcerServlet

web.xml

<!--    配置springmvc的前端控制器-->
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
    <!--  监听器-->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
<!--    全局配置初始化参数-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

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

<!--mvc 组件扫描-->
<context:component-scan base-package="com.zhongcode.controller"/>

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;
}

回写数据

直接写

@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("访问成功");
}

@ResponseBody

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

返回对象和集合

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

<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>

<mvc:annotation-driven/>
使用==<mvc:annotation-driven/>==默认底层就会集成jackson进行对象或集合的json格式字符串的转换。

SpringMVC 数据获取

基本类型参数

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

POJO参数参数

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

数组类型参数

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

集合类型参数

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

配置全局乱码过滤器

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

<!--    配置全局乱码过滤器-->
    <filter>
        <filter-name>characterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

参数绑定注解@requestParam

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

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

自定义类型转换器

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

定义转换器类实现Converter接口
在配置文件中声明转换器
在<annotation-driven>中引用转换器

public class DateConverter implements Converter<String, Date> {
    @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;
    }
}

<!-- MVC注解驱动-->
    <mvc:annotation-driven conversion-service="conversionService"/>
<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
        <list>
            <bean id="" class="com.zhongcode.converter.DateConverter"/>
        </list>
    </property>
</bean>

获得请求头@RequestHeader

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

@RequestHeader注解的属性如下:

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

文件上传(多文件上传)

1.构建表单

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

<form action="${pageContext.request.contextPath}/uploadFile" method="post" enctype="multipart/form-data">
    <input type="file" name="file" /><br/>
    <input type="file" name="file" /><br/>
    <input type="file" name="file" /><br/>
    <input type="submit" value="上传" />
</form>

2.添加上传IO的jar包

<!-- 已省略spring springmvc的jar-->
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
</dependency>
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
</dependency>

3.配置SpringMVC处理器

注意解析器id不能修改

<!-- 配置文件上传解析器 multipartResolver 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>

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";
}

SpringMVC拦截器

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

区别	过滤器（Filter）	拦截器（Interceptor）
使用范围	是servlet 规范中的一部分，任何Java Web 工程都可以使用	是SpringMVC 框架自己的，只有使用了SpringMVC 框架的工程才能用
拦截范围	在url-pattern 中配置了/*之后，可以对所有要访问的资源拦截	在<mvc:mappingpath=“”/>中配置了/**之后，也可以多所有资源进行拦截，但是可以通过<mvc:exclude-mappingpath=“”/>标签排除不需要拦截的资源

拦截器入门

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");
    }
}

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

<!--    配置拦截器-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--            对那些资源执行-->
        <mvc:mapping path="/**"/>
        <bean class="com.zhongcode.interceptor.AInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

方法详细

方法名	说明
preHandle()	方法将在请求处理之前进行调用，该方法的返回值是布尔值Boolean类型的，当它返回为false时，表示请求结束，后续的Interceptor和Controller都不会再执行;当返回值为true时就会继续调用下一个Interceptor的preHandle方法
postHandle()	该方法是在当前请求进行处理之后被调用，前提是preHandle方法的返回值为true 时才能被调用，且它会在DispatcherServlet进行视图返回渲染之前被调用，所以我们可以在这个方法中对Controller处理之后的ModelAndView对象进行操作
afterCompletion()	该方法将在整个请求结束之后，也就是在DispatcherServlet渲染了对应的视图之后执行，前提是preHandle方法的返回值为true时才能被调用

SpringMVC异常处理

使用SpringMVC简单异常处理器

SimpleMappingExceptionResolver

<!--SpringMVC简单异常处理-->
    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        <!--默认处理视图-->
        <property name="defaultErrorView" value="404"/>
        <property name="exceptionMappings">
            <map>
  				<!--key：异常类，value：处理视图-->
                <entry key="com.zhongcode.exception.MyException" value="500"/>
            </map>
        </property>
    </bean>

自定义处理器

编写异常处理类实现接口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();
}

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();
}

概念

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

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

XML 配置AOP 详解

切点表达式的写法

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

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

通知的类型

语法

<aop:通知类型 method=“切面类中方法名” pointcut=“切点表达式"></aop:通知类型>

<aop:config>
    <!--声明切面-->
    <aop:aspect ref="myAspect">
        <aop:before method="before" pointcut="execution(* com.zhongcode.aop.Target.save())"/>
    </aop:aspect>
</aop:config>

名称	标签	说明
前置通知	<aop:before>	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	<aop:after-returning>	用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知	<aop:around>	用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
异常抛出通知	<aop:throwing>	用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知	<aop:after>	用于配置最终通知。无论增强方式执行是否有异常都会执行

切面表达式可以抽取

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

注解配置

注解aop开发步骤

使用@Aspect标注切面类
使用@通知注解标注通知方法
在配置文件中配置aop自动代理<aop:aspectj-autoproxy/>通知注解类型

名称	注解	说明
前置通知	@Before	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	@AfterReturning	用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知	@Around	用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
异常抛出通知	@AfterThrowing	用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知	@After	用于配置最终通知。无论增强方式执行是否有异常都会执行#

卑微小钟

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
SSM框架学习笔记

SpringMVC默认已经提供了一些常用的类型转换器，例如客户端提交的字符串转换成int型进行参数设置。·但是不是所有的数据类型都提供了转换器，没有提供的就需要自定义转换器，例如:日期类型的数据就需要自定义转换器。定义转换器类实现Converter接口在配置文件中声明转换器在中引用转换器@Override// 将日期字符串转成日期对象返回try {}}}...
复制链接

扫一扫