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 | 用于配置最终通知。无论增强方式执行是否有异常都会执行# |