JAVA框架

java 专栏收录该内容
10 篇文章 0 订阅

Spring

Spring是一个基于IOC和AOP的结构J2EE系统的框架,对象的生命周期由Spring来管理
IOC(Inversion Of Control):控制反转
DI(Dependency Inject): 依赖注入
AOP(Aspect Oriented Program):面向切面编程(实现周边功能,比如性能统计,日志,事务管理等)
方法
新建对象的set和get方法
新建bean configuration … - applicationContext.xml、并在这个xml配置文件(SpringIOC容器)中使用Bean创建对象并且给对象及其属性赋值

    <bean id="id(唯一)" class="包名.类名">
        <property name="属性名" value="属性值" />
        <property name="属性名" ref="属性映射(对应对象的id值)" />
    </bean>

然后通过主函数中 ApplicationContext取出对象

 public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        类 实例名 = (类名) context.getBean("id");

三种依赖注入方式:set方法注入(同上)、构造方法注入( < constructor-arg value(ref)=“value” type=“type” index=“0” name=“属性名”>< /constructor-arg>)、p命名空间注入(引入p命名空间、简单类型:p:属性名=“属性值”、引用类型(除了String外):p:属性名-ref=“引用的id”)
IOC容器赋值:如果是简单类型(8个基本+String),value; 如果是对象类型,ref=“需要引用的id值”,因此实现了对象与对象之间的依赖关系、赋值null< property name=“name” > < null/>< /property>、赋值空值< property name=“name” > < value>< /value> < /property>、集合类型赋值proprety中使用< set> < list> < array>等,可以混着用。注意< map> 中使用< entry> < key>< value>
value与< value>注入方式的区别:value必须使用双引号,不能使用type属性,只能采用实体引用处理特殊符号,后者可以使用<![CDATA[ ]]>标记处理特殊符号
自动装配:bean中的autowire只适用于ref类型,autowire=“byName|byType|constructor|no”、实现全局自动装配default-autowire=“byName|by…”、注解形式的自动装配@Autowired、默认是byType、 @Qualifier(“id”)、改为byName
使用注解
ApplicationContext中增加扫描包

< context:component-scan base-package="包名">
</ context:component-scan>

对应包中加入注解:@Component(“id”)细化:(dao层注解:@Repository)(service层注解:@Service)(控制器层注解:@Controller)
使用注解实现声明式事务:实现数据库的事务
配置:配置数据库相关、配置事务管理器txManager、增加对事务的支持;使用:方法明前增加注解@Transactional并增加其属性和方法
AOP:前置通知、后置通知、环绕通知、异常通知
实现方式:实现类、实现接口、注解、配置
接口形式AOP:实现接口并重写方法(前置MethodBeforeAdvice)(后置AfterReturningAdvice)(环绕MethodInterceptor)(异常ThrowsAdvice)、 ApplicationContext中加入业务类方法的对象和通知类方法的对象、增加配置:

< aop:config>
		<!-- 切入点(连接线的一端:业务类的具体方法) -->
		< aop:pointcut expression="execution(public * 业务类名.方法名(参数类型))"   id="poioncut"/>
		<!-- (连接线的另一端:通知类) -->
        < aop:advisor advice-ref="通知类名"  pointcut-ref="poioncut" />
</aop:config>

环绕通知:可以获取目标方法的全部控制权,目标方法的一切信息可以通过invocation参数获取到,底层是通过拦截器实现的、环绕通知类实现MethodInterceptor接口和invoke方法, result = invocation.proceed() ;中result获得返回值,invocation.proceed()实现业务类方法执行,try中实现前置通知和后置通知、catch中捕获异常并实现异常通知
注解形式AOP:@Component引入注解识别@Aspect修饰类形成通知类 @Before(pointcut=“execution(public * 业务类名.方法名(参数类型))”)修饰方法形成通知前置方法、后置@AfterReturning(returning=“returningValue”)、异常@AfterThrowing(throwing=“e”)、环绕@Around、方法中的参数可以使用JoinPoint jp、返回值参数Object returningValue、返回异常参数NullPointerException e、环绕通知中参数使用ProceedingJoinPoint jp
配置:增加扫描包、开启AOP注解代理< aop:aspectj-autoproxy>< /aop:aspectj-autoproxy>
配置形式AOP:写通知类logSchema及其通知方法,并将通知类和业务类加入到IOC容器中,applicationContext配置:

<aop:config>
		<!-- 切入点(连接线的一端:业务类的具体方法) -->
		<aop:pointcut expression=""   id="pcShema"/>
		<!-- 原方法(连接线的另一端:通知类)<aop:advisor advice-ref="logSchea"  pointcut-ref="pcShema" />-->
		 <!-- schema方式 -->
		 <aop:aspect ref="logSchema">
		 <!-- 连接线:连接业务和通知before -->
		 <aop:before method="before" pointcut-ref="pcShema"/>
		 <!-- 连接线:连接业务和通知afterReturning -->
		 <aop:after-returning method="afterReturning" returning="returnValue" pointcut-ref="pcShema"/>
		 <!-- 连接线:连接业务和通知Exception -->
		 <aop:after-throwing method="Exception" pointcut-ref="pcShema" throwing="e"/>
		 <!-- 环绕通知 -->
		 <aop:around method="around" pointcut-ref="pcShema" />
         </aop:aspect>
</aop:config>

WEB项目整合Spring
IOC初始化:当服务启动时(tomcat),通过监听器将SpringIOC容器初始化一次(该监听器 spring-web.jar已经提供)web.xml配置、推荐方法:

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
  			classpath:applicationContext.xml,
  			<!--.默认约定的位置:WEB-INF/applicationContext.xml-->
  			classpath:applicationContext-*.xml
  	</param-value>
</context-param>

将applicationContext分层:cotroller、service、dao并分别实例化和依赖注入
实现Web容器和IOC容器的整合(手动方式):从IOC容器中求出实例对象、一般在servlet初始化中实现

public void init() throws ServletException  {
		//ApplicationContext context= new ClassPathXmlApplicationContext("applicationContext-Service");
		ApplicationContext context=WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());
		studentService=(IStudentService)context.getBean("studentService");
		<!--类 实例名 = (类名) context.getBean("id");-->
	}

最后完善web项目

Spring进阶

注解形式存放bean
(配置类)必须有@Configuration注解

//存bean
@bean
//取bean
ApplicationContext context  = new AnnotationConfigApplicationContext(配置类.class) ;

三层组件:(@Controller、@Service、@Repository -> @Component)+配置文件或者注解扫描器@component-scan(只对三层组件负责)、扫描器指定规则(FilterType(ANNOTATION,ASSIGNABLE_TYPE,CUSTOM))
非三层组件(转换器): @Bean+方法的返回值、@import(直接编写到@Import中且id值是全类名、——自定义ImportSelector接口的实现类,通过selectimports方法实现(方法的返回值就是要纳入IoC容器的Bean),并且告知程序自己编写的实现类@Import({Orange.class,MyImportSelector.class})、——编写ImportBeanDefinitionRegistrar接口的实现类,重写方法
@Import({Orange.class,MyImportSelector.class,ImportBeanDefinitionRegistrar.class})并且告知程序自己编写的实现类)、FactoryBean(工厂Bean、准备bean实现类和重写方法,注册bean注册到@Bean中)
bean的作用域:scope(singleton)单例默认值、@scope(prototype)多实例(singleton:容器在初始化时,就会创建对象(唯一的一个),支持延迟加载@Lazy、prototype:容器在初始化时,不创建对象;只是在每次使用时创建对象)
条件注解:可以让某一个Bean在某些条件下加入Ioc容器,其他情况下不加入容器,通过实现condition接口
Bean的生命周期:创建(new …)、初始化(赋初值)、 …、销毁
@Bean+返回值方式

@Bean(value="stu",initMethod = "myInit",destroyMethod = "myDestroy") 

三层组件功能性注解方式:将响应组件加入@Component(value="")注解、 给初始化方法加@PostConstruct、给销毁方法加@PreDestroy
三次组件接口方法:InitializingBean初始化、DisposableBean 销毁并实现其中的方法
接口BeanPostProcessor:拦截了所有中容器的Bean,并且可以进行bean的初始化 、销毁
BeanFactoryPostProcessor:bean被实例化之前
BeanDefinitionRegistryPostProcessor:bean被加载之前
具体顺序:BeanDefinitionRegistryPostProcessor(a) ->加载bean->BeanFactoryPostProcessor(b)->实例化bean->BeanPostProcessor
自动装配
@Autowired根据类型自动注入、结合@Qualifier("")根据名字注入、默认值@primary、@Autowired(required=false)修改未匹配为null
三层组件:如果@Autowired在属性前标注则不调用set方式;如果标注在set前面则调用set方式;不能放在方法的参数前
Bean+返回值:@Autowired可以在方法的参数前(也可以省略)、方法前(如果只有一个有参构造方法则@Autowired也可以省略)
@Resource根据名字自动注入,没有名字然后根据类型
@Inject默认根据类型匹配(引入jar包)
底层组件:实现Aware的子接口,从而获取到开发的组件对象,对对象进行操作
环境切换:bean前@Profile说明条件注入
激活
1.运行环境中设置参数-Dspring.profiles.active=@Profile环境名
2.硬编码:IoC容器在使用时必须refresh(),需要设置保存点|配置类的编写处

//注解方式
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext() ;
ConfigurableEnvironment environment = (ConfigurableEnvironment)context.getEnvironment();
environment.setActiveProfiles("@Profile环境名");
//保存点
context.register(配置类名.class);
context.refresh();

监听器:可以监听事件,监听的对象必须是ApplicationEvent自身或其子类/子接口
1.监听类实现ApplicationEvent接口
2.监听类注解形式申明是监听方法

@Component
public class MyListener {
//本方法是一个监听方法
@EventListener(classes = {ApplicationEvent.class})
public void myListenerMethod(ApplicationEvent event){
System.out.println("--0000000--------"+event);
    }
}

SpringMVC

SpringMVC构建Web应用程序的全功能MVC模块
配置与使用
JSP发出请求
将Servlet的访问通过web.xml配置文件拦截请求,交给SpringMVC处理、快速创建:alt+/ dispatcherServlet

	<!-- The front controller of this Spring Web application, responsible for handling all application requests -->
	<servlet>
		<servlet-name>springDispatcherServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<!--默认路径/WEB-INF/springDispatcherServlet-servlet.xml-->
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:springmvc.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>

	<!-- Map all requests to the DispatcherServlet for handling -->
	<servlet-mapping>
		<servlet-name>springDispatcherServlet</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>

springmvc.xml中配置扫描包和视图解析器(用于解析返回值地址并通过请求转发实现页面跳转)

	<!--配置视图解析器(InternalResourceViewResolver)  -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/views/"></property>
		<property name="suffix" value=".jsp"></property>
	</bean>
	<!--view-name会被视图解析器加上前缀和后缀  -->

控制器中添加注解@controller(实现扫描包扫描)@RequestMapping(映射匹配类、类之前)、@RequestMapping(value,method,params)(映射匹配方法、方法之前)(可以增加个属性和约束条件对请求参数进行约束)、@PathVariable获取动态参数
REST风格:GET :查、POST :增、DELETE :删、PUT :改
springmvc实现给普通浏览器增加 put|delete请求方式 :put|post请求方式的步骤:
1.web.xml增加HiddenHttpMethodFilte过滤器

<filter>
			<filter-name>HiddenHttpMethodFilte</filter-name>
			<filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>
<filter-mapping>
			<filter-name>HiddenHttpMethodFilte</filter-name>
			<url-pattern>/*</url-pattern>
</filter-mapping>

2.表单提交必须是post方法且通过隐藏域的value值设置实际的请求方式DELETE|PUT (< input type=“hidden” name="_method" value=“DELETE”/>)
3.控制器实现提交方式约束匹配、参数获取和功能执行
处理数据模型:跳转时需要带数据和页面(ModelAndView、ModelMap、Map、Model -数据放在了request作用域)
ModelAndView:

public ModelAndView testModelAndView() {
ModelAndView mv = new ModelAndView("jsp");
mv.addObject("属性名", 属性值或对象);
return mv;}

ModelMap:

public String testModelMap(ModelMap mm) {
mm.put("属性名", 属性值或对象);
return "jsp";}

Map:

public String testMap(Map<String,Object> m) {
m.put("属性名", 属性值或对象);
return "jsp";}

Model:

public String testMode(Model model) {
model.addAttribute("属性名", 属性值或对象);
return "jsp";}

@SessionAttributes(value\type):实现将数据放在request中的同时也将数据放在session中
@ModelAttribute:通过@ModelAttribute修饰的方法,会在每次请求前先执行;并且该方法的参数map.put()可以将对象放入即将查询的参数中,可以进行属性值的修改
视图的顶级接口:Views
视图解析器的顶级接口:ViewsResolver
国际化:针对不同地区、不同国家进行不同的显示 (创建资源文件、配置springmvc.xml并加载资源文件、通过jstl使用国际化)

<!--加载国际化资源文件-->
	<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
	<property name="basename" value="i18n"></property>
	</bean>

请求方法改变:return “redirect:/views/success.jsp”;
直接跳转(不通过控制器):< mvc:view-controller path=“handle/a” view-name=“success” /> < mvc:annotation-driven></ mvc:annotation-driven>
静态资源访问:(MVC交给Servlet处理)加入配置:

<!--该注解会让springmvc:接收一个请求,并且该请求没有对应@requestmapping时,将该请求交给服务器默认的servlet去处理(直接访问)-->
<mvc:default-servlet-handler></mvc:default-servlet-handler>
<mvc:annotation-driven></mvc:annotation-driven>

类型转换:Spring自带一些常见的类型转换器、自定义类型转换器MyConverter(编写自定义类型转换类并引入接口Converter、配置将MyConverter加入到springmvc中、测试转换器)@RequestParam(“name”)是触发转换器的桥梁
格式化:springMVC配置数据格式化注解所依赖的bean+通过注解使用@DateTimeFormat(pattern=“yyyy-MM-dd”)@NumberFormat(parttern="###,#") 、错误消息处理(参数BindingResult result返回前面参数的错误信息,可以放在map里面传递到前端打印)、数据检验:JSR303和Hibernate Validator(jar包+配置(自动加载一个LocalValidatorFactoryBean类)+注解(给校验的对象前增加@Valid))
JSON:@ResponseBod修饰的方法,会将该方法的返回值以一个json数组的形式返回给前台
文件上传:配置MultipartResolver将其加入springIOC容器(可以设置属性)、处理方法中(参数@RequestParam(“file”) MultipartFile file获取前端传过来的文件数据)根据IO方法写输入输出流
拦截器:原理和过滤器原理相同(编写拦截器实现HandlerInterceptor接口、处理请求响应和渲染过程+将自己写的拦截器配置到springmvc中(< mvc:interceptor>))
异常处理:如果一个方法用于处理异常,并且只处理当前类中的异常:@ExceptionHandler({Exception.class});如果一个方法用于处理异常,并且处理所有类中的异常: 类前加@ControllerAdvice、 处理异常的方法前加@ExceptionHandler;自定义异常显示页面@ResponseStatus;
通过配置实现的异常处理:SimpleMappingExceptionResolver

<bean  class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
		<!-- 如果发生异常,异常对象会被保存在  exceptionAttribute的value值中;并且会放入request域中;异常变量的默认值是exception-->
		<!--<property name="exceptionAttribute" value="exception"></property>-->
			<property name="exceptionMappings">
					<props>
						<!-- 相当于catch(ArithmeticException exception){ 跳转:error页面 } -->
						<prop key="java.lang.ArithmeticException">error</prop>
						<prop key="java.lang.NullPointerException">error</prop>
					</props>
			</property>
</bean>

Mybatis

Mybatis可以简化JDBC操作和实现数据的持久化
ORM:Object Relational Mapping开发人员 像操作对象一样操作数据库表
SqlSessionFactory -> SqlSession ->StudentMapper ->CRUD
配置与使用
引入mybatis-jar包和数据库jar包
配置mybatis
conf.xml:配置数据库信息和需要加载的映射文件(运行环境默认是development、可以通过build的第二参数指定数据库环境)

PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<!--如果使用的事务方式为jdbc,则需要手工commit提交,即session.commit()-->
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="org/mybatis/example/BlogMapper.xml"/>
</mappers>
</configuration>

表 - 类
映射文件xxMapper.xml :增删改查标签< select>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.mybatis.example.BlogMapper">
<select id="selectBlog" resultType="Blog" parameterType="int>
<!--parameterType:输入参数的类型,resultType:返回类型、输入参数parameterType 和输出参数resultType,在形式上都只能有一个、如果输入参数:是简单类型(8个基本类型+String)是可以使用任何占位符,#{xxxx}、如果是对象类型,则必须是对象的属性#{属性名}-->
select * from Blog where id = #{id}
</select>
</mapper>

测试类
session.selectOne(“需要查询的SQL的namespace.id”,“SQL的参数值”)

public static void main(String[] args) throws IOException {
		//加载MyBatis配置文件(为了访问数据库)
		Reader reader = Resources.getResourceAsReader("conf.xml") ;
		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader) ;
		//session - connection
		SqlSession session = sessionFactory.openSession() ;
		String statement = "org.lanqiao.entity.personMapper.queryPersonById" ;
		Student person = session.selectOne( statement,1 ) ;
		System.out.println(person);
		session.close(); 

mapper动态代理方式CRUD:省略掉statement,即根据约定直接可以定位出SQL语句
配置环境:mybatis.jar/ojdbc.jar、conf.xml、mapper.xml
新建类和方法实现接口必须遵循以下约定:
1.方法名和mapper.xml文件中标签的id值相同
2.方法的输入参数和mapper.xml文件中标签的parameterType类型一致 (如果mapper.xml的标签中没有parameterType,则说明方法没有输入参数)
3.方法的返回值和mapper.xml文件中标签的resultType类型一致(无论查询结果是一个还是多个(student、List< Student>),在mapper.xml标签中的resultType中只写 一个(Student);如果没有resultType,则说明方法的返回值为void)
4.namespace的值就是接口的全类名( 接口 - mapper.xml 一 一对应)
5.测试中使用

T t = session.getMapper(接口.class) ;
返回类 返回值 = t.接口中的方法(参数) ;//接口中的方法->SQL语句
StudentMapper studentMapper = session.getMapper(StudentMapper.class) ;
studentMapper.方法();

6.优化:将配置信息单独放入db.properties文件中然后再动态引入、MyBatis全局参数在conf.xml中设置、设置别名
类型转换器(自定义):实现java类型和jdbc类型的相互转化
1.创建转换器:实现TypeHandler接口或者继承BaseTypeHandler
2.配置conf.xml< typeHandlers>和mapper.xml与类对应(resultMap可以实现类型转换和属性-字段的映射关系)
输入参数:parameterType(简单类型:8个基本类型+String、.对象类型)、取值方法(#{}、${}都可以获取对象值和嵌套类型对象)(不同之处:简单类型的标识符、#{}会给String类型加上单引号、#{}可以防止sql注入)、参数类型为HashMap(用map中key的值匹配占位符#{stuAge},如果匹配成功就用map的value替换占位符)、参数为多个数据(可以使用[arg3, arg2, arg1, arg0, param3, param4, param1, param2]、在接口中通过@Param(“sNo”) 指定sql中参数的名字)
输出参数:resultType、resultMap(实体类的属性、数据表的字段: 类型、名字不同时、除此之外:实体类属性和数据字段不匹配时可以使用resultType+HashMap)、(输出类型为简单类型、对象类型、集合类型(resultType依然写集合的元素类型)、hashmap类型(本身是一个集合,可以存放多个元素))
输出参数为Hashmap

//根据@MapKey("stuNo")知道 Map的key是stuNo
    @MapKey("STUNO")  //oracle的元数据(字段名、表名 )都是大写
    HashMap<Integer,Student> queryStudentsByHashMap();
//程序根据select的返回值 知道map的value就是 Student ,
    <select id="queryStudentsByHashMap" resultType="HashMap">
         select stuNo ,stuName ,stuAge  from student
    </select>

储存过程:数据库新建储存过程、Mapper中使用CALL调用存储过程(通过statementType="CALLABLE"设置SQL的执行方式是存储过程、存储过程的输入参数需要通过HashMap来指定)、使用过程(通过hashmap的put方法传入输入参数的值、通过hashmap的Get方法获取输出参数的值。)
动态sql语句:where-if(只能处理第一个有效的and)

<select id="queryStuByNOrAWishSQLTag" 	 parameterType="student"	resultType="student" >
		select stuno,stuname,stuage from student
		<where>
			<!-- <if test="student有stuname属性 且不为null"> -->
			<if test="stuName !=null and stuName!=''  "> 
				and stuname = #{stuName}
			</if>
			<if test="stuAge !=null and stuAge!=0  "> 
				 and stuage = #{stuAge}
			</if>
		</where>
	</select>

foreach:< foreach>迭代的类型:数组、对象数组、集合、属性(包括属性类)、(简单类型的数组:在mapper.xml中必须用array代替该数组、集合类型的数组:必须用list代替该集合、对象数组:必须用object代替该集合、使用时用对象.属性)

	<select id="queryStudentsWithNosInGrade"  parameterType="grade" resultType="student">
	  	select * from student 
	  	<where>
	  		 <if test="stuNos!=null and stuNos.size>0">
	  		 	<foreach collection="stuNos" open=" and  stuno in (" close=")" 
	  		 		item="stuNo" separator=",">   
	  		 		#{stuNo}
	  		 		<!--此时stuNo为对象的属性,本身是一个集合-->
	  		 	</foreach>
	  		 </if>
	  	</where>
	</select>

refid:(提取并引用sql语句)
trim:增删改中有效使用

//添加where并处理拼接sql中开头或结尾的第一个和最后一个and
<trim prefix="where" prefixOverrides="and" suffixOverrides="and">

关联查询:一对一(业务扩展类核心:用resultType指定类的属性包含多表查询的所有字段、resultMap:通过属性成员建立起对应关系,对象成员使用 association映射、javaType指定该属性的类型(一对一:association,一对多:collection))一对多:resultMap:通过属性成员建立起对应关系,对象成员使用 collection映射、ofType指定该属性中元素的类型
日志:通过日志信息,详细的阅读mybatis执行情况
log4j.jar包、开启日志conf.xml、编写配置日志输出文件log4j.properties

<settings>
<!-- 开启日志,并指定使用的具体日志 -->
<setting name="logImpl" value="LOG4J"/>
</settings>

延迟加载:实现部分查找和懒加载
开启延迟加载conf.xml、配置mapper.xml(查询对象的sql是通过select属性指定的关联mapper,并且通过column指定外键名)、如果增加了mapper.xml,要修改conf.xml配置文件(将新增的mapper.xml加载进去)

<settings>
<!-- 开启延迟加载 -->
<setting name="lazyLoadingEnabled" value="true"/>
<!-- 关闭立即加载 -->
<setting name="aggressiveLazyLoading" value="false"/>
</settings>

查询缓存
一级缓存:MyBatis默认开启一级缓存,如果用同样SqlSession对象查询相同的数据,则只会在第一次查询时向数据库发送SQL语句,并将查询的结果 放入到SQLSESSION中(作为缓存在);后续再次查询该同样的对象时,则直接从缓存中查询该对象即可(即省略了数据库的访问)、commit语句会清理数据库缓存
二级缓存:只要产生的Mapper对象来自于同一namespace,则这些对象共享二级缓存
conf.xml中配置二级缓存< setting name=“cacheEnabled” value=“true”/>
mapper.xml中声明开启 < cache/>
Mapper的对应类、对应类的父类和级联属性都要需要实现序列化接口Serializable
触发将对象写入二级缓存的时机为SqlSession对象的close()方法
禁用二级缓存:select标签中 useCache=“false”
清理二级缓存:select标签中 flushCache="true"或者 其他操作的commit(),不能用查询的commit();
ehcache二级缓存整合:jar包、编写ehcache配置文件 Ehcache.xml、Mapper.xml中开启

<cache  type="org.mybatis.caches.ehcache.EhcacheCache">
<property name="maxElementsInMemory" value="2000"/>
<property name="maxElementsOnDisk" value="3000"/>
</cache>

逆向工程:表、类、接口、mapper.xml四者密切相关,根据表生成其他三个
jar包:mybatis-generator-core.jar、mybatis.jar、ojdbc.jar
逆向工程的配置文件generator.xml
执行

public static void main(String[] args) throws IOException, XMLParserException, InvalidConfigurationException, SQLException, InterruptedException {
        //配置文件
		File file = new File("src/generator.xml") ;
		List<String> warnings = new ArrayList<>();
		ConfigurationParser cp = new ConfigurationParser(warnings);
		Configuration config = cp.parseConfiguration(file);
		DefaultShellCallback callBack = new DefaultShellCallback(true);
		//逆向工程的核心类
		MyBatisGenerator generator = new MyBatisGenerator(config, callBack,warnings  );
		generator.generate(null);
	}

增加conf.xml和db.properties文件
使用query by CriteriaQBC

Mybatis进阶

数据库版本切换
conf.xml切换environment并配置Provider别名

<!-- 配置数据库支持类-->
<databaseIdProvider type="DB_VENDOR">
        <property name="MySQL" value="mysql" />
        <property name="Oracle" value="oracle" />
</databaseIdProvider>

mapper.xml写不同数据SQL语句,配置databaseId=“Provider别名”

<select id="queryStudentByNoWithONGL" parameterType="student" resultType="student" databaseId="oracle">

注解方式
将sql语句写在接口的方法上@Select("")
将接口的全类名写入< mapper>,或者批量写入

<mappers>
	<!--以下可以将com.yanqun.mapper 包中的注解接口和xml全部一次性引入 -->
    <package name="com.yanqun.mapper" />
</mappers>

增删改返回值可以是void、Integer、Long、Boolean,都不需要在mapper.xml中设置返回值类型
事务提交

//手动提交:
  sessionFactory.openSession();
  session.commit();
//自动提交:每个dml语句 自动提交
  sessionFactory.openSession(true);

自增语句

//mysql设置自增数据为Integer类型的null,设置返回的自增数据,实现回写
useGeneratedKeys="true" keyProperty="number"
//oracle通过序列模拟实现(before和after方式)

鉴别器 : 对查询结果进行分支处理: 如果是a年级则真名,如果b年级显示昵称,由于字段不一致需要在resultMap中写

<discriminator javaType="string"  column="gname">
    <case value="a" resultType="com.yanqun.entity.Student" >
         <result  column="sname" property="stuName"/>
    </case>
    <case value="b" resultType="student">
         <result  column="nickname" property="stuName"/>
    </case>
</discriminator>

架构分析
接口层:广义接口(增删改查)
数据处理层:参数处理,sql解析与执行,处理结果
框架支撑层:事务管理,缓存机制,连接池管理
引导层:XML配置,注解方式
源码分析
获取SqlSessionFactory对象
(通过parseConfiguration()在configuration标签设置了properties、settings、environments等属性标签)(所有的配置信息放在Configuration对象中)(解析所有的Mapper.xml文件(分析其中的增删改查标签)成MappedStatement对象并放在Configuration中)(SqlSessionFactory对象 ->DefaultSqlSessionFactory ->Configuration ->包含了一切配置信息)
获取SqlSession对象
(根据不同的类型execType,产生不同的 Executorconfiguration.newExecutor(tx, execType) ->SimpleExecutor、通过装饰模式将刚才产生的executor包装成一个更加强大的executor:executor = (Executor) interceptorChain.pluginAll(executor)、返回DefaultSqlSession(configuration,executor,事务))
(SqlSession ->openSession()->openSessionFromDataSource()->DefaultSqlSession对象->执行SQL)
获取XxxMapper对象
(代理接口中的方法、mapper.xml中的< select>等标签)(SqlSession(configuration,executor,事务)、代理接口的对象(MapperInterface)、methodCache(存放查询缓存,底层是CurrentHashMap))
执行< select>等标签中定义的SQL语句
(MyBatis底层在执行CRUD时 可能会涉及到四个处理器:处理对象ParameterHandler的处理器:StatementHandler、处理参数的处理器:ParameterHandler、类转化器处理器:TypeHandler、处理结果集的处理器:ResultSetHandler)(动态代理:MapperProxy对象、执行增删改查->MapperProxy/invoke()–>InvocationHandler :JDK动态代理接口)(实际调用增删改查的方法:mapperMethod.execute(sqlSession,args) )(处理增删改查方法的参数:method.convertArgsToSqlCommandParam(args))(boundSql :将我们写的SQL和参数值进行了拼接后的对象,即最终能被真正执行的SQL)(通过Executor执行sql语句、底层执行方法:PreparedStatement的execute())
自定义插件
四大核心对象:都涉及到了拦截器用于增强并且包含了该增强操作
StatementHandler、ParameterHandler、ResultSetHandler、Executor
步骤
编写拦截器

//目標方法target
        Object target = invocation.getTarget();
//目标对象target的包装后的产物MetaObject
        MetaObject metaObject = SystemMetaObject.forObject(target);
//metaObject.getValue获取参数
        Object value = metaObject.getValue("parameterHandler.parameterObject");
//metaObject.setValue设置参数
        metaObject.setValue("parameterHandler.parameterObject",2);
//放行
        Object proceed = invocation.proceed();
        return proceed;

编写签名注解

@Intercepts({
//@Signature(type = StatementHandler.class , method ="query",args = {Statement.class, ResultHandler.class})
@Signature(type = StatementHandler.class , method ="parameterize",args = {Statement.class})
})

conf.xml配置

<plugins>
        <plugin interceptor="com.yanqun.my.interceptors.MyInterceptor">
            <property name="name" value="zs"/>
            <property name="age" value="23"/>
        </plugin>
</plugins>

批量操作:预编译一次sessionFactory.openSession(ExecutorType.BATCH)、不推荐拼接SQL方式
分页插件:PageHelper
引入jar(jsqlparser-0.9.5.jar、pagehelper-5.1.8.jar)
配置conf.xml插件
执行PageHelper.startPage(当前页, 每页数据)
使用页面信息(PageInfo、Page对象)
插件:Mybatis-Plus、通用Mapper

Maven

Maven是一个基于Java平台的自动化构建工具–将java、js、jsp等各个文件进行筛选、组装,变成一个可以直接发布的项目
http://www.mvnrepository.com
清理:删除编译的结果,为重新编译做准备
编译:java->class
测试:针对于项目中的关键点进行测试,亦可用项目中的测试代码去测试开发代码;
报告:将测试的结果进行显示
打包:将项目中包含的多个文件 压缩成一个文件, 用于安装或部署:(java项目-jar、web项目-war)
安装:将打成的包放到本地仓库,供其他项目使用
部署:将打成的包放到服务器上准备运行
下载配置maven
使用maven
mvn compile 只编译main目录中的java文件
mvn test 测试
mvn package 打成jar/war
mvn install 将开发的模块放入本地仓库供其他模块使用(放入的位置是通过gav决定)
mvn clean 删除target目录(删除编译文件的目录)
运行mvn命令必须在pom.xml文件所在目录
目录结构

-src				
	--main		          程序功能代码
		--java		      java代码  
		--resources       资源代码、配置代码
	--test			      测试代码
		--java			
		--resources	
pom.xml                   项目对象模型

POM(项目对象模型):Maven工程的基本工作单元XML文件,包含了项目的基本信息,用于描述项目如何构建,声明项目依赖

	<groupId>域名翻转.项目名</groupId>
	<groupId>org.lanqiao.maven</groupId>

	<artifactId>子模块名</artifactId>
	<artifactId>HelloWorld</artifactId>

	<version>版本号</version>
	<version>0.0.1-SNAPSHOT</version>

依赖
在maven项目中如果要使用一个当时不存在的Jar或模块,则可以通过依赖实现(例如依赖测试类)

<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.0</version>
	<scope>test</scope>
</dependency>

依赖排除:

<exclusions>
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
</exclusion>
</exclusions>

依赖关联:
A.jar->B.jar->C.jar
要使 A.jar ->C.jar:当且仅当 B.jar依赖于C.jar的范围是compile
依赖原则:路径最短原则(防止冲突)
路径相同距离:同一个pom文件后覆盖前、不同pom文件前覆盖后
统一编号和版本:

<properties>  
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<xx>版本号</xx>
</properties>  
 //使用动态版本
 <version>${xx} </version>

生命周期
clean lifecycle :清理 pre-clean、clean、post-clearn
default lifecycle :默认(常用)
site lifecycle:站点 pre-site、site、post-site site-deploy
继承
父->子工程,可以通过父工程 统一管理依赖的版本
父工程pom方式打包
在父工程pom中编写依赖

<dependencyManagement>
  	<dependencies>
  		<dependency>

给当前工程继承父工程

<parent>
<!-- 1加入父工程坐标gav -->
<groupId>org.lanqiao.maven</groupId>
<artifactId>B</artifactId>
<version>0.0.1-SNAPSHOT</version>
<!-- 2当前工程的Pom.xml到父工程的Pom.xml之间的相对路径 --> 
<relativePath>../B/pom.xml</relativePath>
</parent>

在子类中需要声明使用哪些父类的依赖

<dependency>
<!-- 声明:需要使用到父类的junit(只需要ga) -->
<groupId>junit</groupId>
<artifactId>junit</artifactId>
</dependency>

聚和
聚合可以将拆分的多个子工程合起来共同操作(前置关联工程的install操作)
新建总工程中配置:只能配置在打包为pom方式的maven中

<modules>
<!--项目的根路径  -->
<module>../Maven1</module>
<module>../Maven2</module>
</modules>

配置完聚合之后,操作总工程会自动操作改聚合中配置过的工程
部署Web
新建Maven项目并打war包
pom中配置servlet-api

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.0.1</version>
    <scope>provided</scope>
</dependency>

补全路径名:webapp->WEB-INF->web.xml
实际开发中开发人员将自己的项目开发完毕后打成war包(package) 交给实施人员去部署

SpringBoot

springboot可以快速开发微服务模块,springboot将各个应用/三方框架设置成了一个个“场景”starthttps://spring.io可以自动生成SpringBoot的文件项目
准备JAVA和MAVEN的环境、实现springboot开发工具、目录结构resources(static:静态资源(js css 图片 音频 视频)
、templates:模板文件(模版引擎freemarker ,thymeleaf;默认不支持jsp)、application.properties: 配置文件对端口号等服务端信息进行配置)
注解
@SpringBootApplication:springboot的主配置类
@Configuration:表示“配置类”:该类是一个配置类 、自动纳入Spring容器(@Component)
@EnableAutoConfiguration:使spring boot可以自动配置:spring boot在启动时,就会将该包及所有的子包全部纳入spring容器,会根据META-INF/spring.factories找到相应的三方依赖,并将这些依赖引入本项目、Xxx_AutoConfiguration会实现自动装配并给予默认值
@SpringBootConfiguration:自己代码的自动配置
@ConditionalOnXxx:当这些条件都满足时此配置自动装配生效(手工修改改 自动装配:XxxProperties文件中的prefix.属性名=value
配置文件
application.properties : k=v,或行内写法(k: v,[Set/List/数组] {map,对象类型的属性},并且 []可省,{}不能省)
application.yml:k:空格v、通过垂直对齐指定层次关系、默认可以不写引号 (双引号会将其中的转义符进行转义)
@Component:将此类型加入Javabean
@ConfigurationProperties(prefix=“student”):根据前缀名实现该类型自动装配,同yml文件相匹配
@Autowired:自动装配从bean中取值
@Value(""):实现单个值注入,可以和全局配置文件实现互补
@Validated:开启jsr303数据校验的注解
@Test:此类型为测试类
@ImportResource(locations={“classpath:spring.xml”}):识别spring.xml配置文件
@bean:通过实现注解配置将此类型加入到bean中

@ConfigurationProperties@Value
注值批量注入单个
松散语法支持不支持
SpEL不支持支持
JSR303数据校验支持不支持
注入复杂类型支持不支持

多环境切换:配置环境切换和动态环境切换
配置文件的位置:properties的优先级要大于yml
外部文件和外部参数:Run configuration ,argumenets方式和命令控制行
日志:spring boot默认选用slf4j和logback、日志级别、日志信息格式、日志输出路径
Web静态资源:静态资源的存放路径通过WebMvcAutoConfiguration类-addResourceHandlers()指定:/webjars/成静态资源存放目录: {“classpath:/META-INF/resources/”,“classpath:/resources/”,“classpath:/static/”,“classpath:/public/”}以上目录存放资源文件后,访问时不需要加前缀、欢迎页(任意一个静态资源目录中的Index.html)、Logo(任意一个静态资源目录中的favicon.ico)、自定义静态资源存放路径(spring.resources.static-locations=…)
Web动态资源:默认不支持jsp、html等,但是推荐使用模板引擎thymeleaf(网页=模板+数据)
引入依赖

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.thymeleaf</groupId>
<artifactId>thymeleaf-spring5</artifactId>
</dependency>
<dependency>
<groupId>org.thymeleaf.extras</groupId>
<artifactId>thymeleaf-extras-java8time</artifactId>
</dependency>

使用thymeleaf只需要将文件放入目录:“classpath:/templates/”; 文件的后缀: “.html”;
thymeleaf的th指定方式和符号取值方式(usingthymeleaf文档)

Dubbo

RPC(Remote Procedure Call):远程过程调用
SOA(Service-Oriented Architecture):面向服务架构
Dubbo中控制器和服务端分离
步骤:提供方服务器运行提供方提供的服务、注册中心发布服务、消费方订阅服务、注册中心推送服务、消费方向提供方调用服务
开发dubbo程序:准备环境(linux环境中的jdk及其环境变量和zookeeper)、服务方(引入依赖:pom.xml、接口及实现类@Service、补全WEB-INF/web.xml、配置spring:applicationContext.xml)、消费方(引入依赖:pom.xml改端口号、补全WEB-INF/web.xml、配置springmvc、编写控制器代码@Reference:用于访问服务方提供的服务代码)、监听器(下载incubator-dubbo-ops、打包war、在linux中的tomcat中运行)

Quartz

quartz:定时执行、异步任务
任务:Job、触发器:定义时间、调度器:将任务和触发器 一一对应
步骤
引入jar包
新建类制定具体任务
新建类任务调用的实现继承Job接口并执行具体任务

public class PlanJob implements Job {
    MeetingService meetingService = new MeetingService();
    //jobExecutionContext可以获取设置的各种参数值
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        TriggerKey triggerkey =
                jobExecutionContext.getTrigger().getKey();
        JobKey jobKey = jobExecutionContext.getJobDetail().getKey();
        System.out.println("----");
        System.out.println(triggerkey+"\n"+jobKey);
        JobDataMap jobDataMap = jobExecutionContext.getJobDetail().getJobDataMap();
        List<String> infos = (List<String>)jobDataMap.get("infos");
        System.out.println(infos);
        //存放 计划执行的任务...
        meetingService.calClassMeeting();
    }
}

新建测试方法类(产生)

public class TestQuartz {
//XxxBuilder ->withIdentity()-->Xxx
public static void main(String[] args) throws SchedulerException, InterruptedException, ParseException {
//        PlanJob
        JobBuilder jobBuilder = JobBuilder.newJob(PlanJob.class);//PlanJob PlanJob PlanJob
        //产生实际使用的Job
        JobDetail jobDetail = jobBuilder.withIdentity("meeting Job", "group1").build();

        //向Job的execute()中传入一些参数。。。
//        JobDatMap
        JobDataMap jobDataMap = jobDetail.getJobDataMap();
        List<String> names = Arrays.asList(new String[]{"zs","ls","ww"});
        jobDataMap.put("infos",names);

        // 触发器(Trigger):时间规则  ,依赖2个对象(TriggerBuilder ,Scheduel)
        TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
        triggerBuilder = triggerBuilder.withIdentity("meeting trigger", "group1");
        triggerBuilder.startNow();//当满足条件时  立刻执行
        // 2019-03-13 09:46:30   --  // 2019-03-13 09:46:45

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date start = sdf.parse("2019-03-13 09:46:30");
        Date end = sdf.parse("2019-03-13 09:46:45");

//        triggerBuilder.startAt(start);
//        triggerBuilder.endAt(end);

        //scheduelBuilder:定执行的周期(时机)
//        SimpleScheduleBuilder scheduelBuilder = SimpleScheduleBuilder.simpleSchedule();
//        scheduelBuilder.withIntervalInSeconds(1) ;//每隔1秒执行一次
//        scheduelBuilder.withRepeatCount(3) ;//重复执行3次
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("5,10,15,30,45 * * * * ? *");
        //产生触发器
        // SimpleTrigger trigger = triggerBuilder.withSchedule(ScheduleBuilder).build();
        CronTrigger trigger = triggerBuilder.withSchedule(cronScheduleBuilder).build();
//        调度器(工厂产生调度器)
         SchedulerFactory secheduleFacotry = new StdSchedulerFactory();
        //产生调度器
        Scheduler scheduler = secheduleFacotry.getScheduler();
        //通过调度器 将 任务 和 触发器一一对应
        scheduler.scheduleJob(jobDetail,trigger) ;
        scheduler.start();
//        scheduler.shutdown(true);
    }
}

框架整合

Spring-MyBatis整合

引入jar包
配置类-表对应
配置Spring配置文件(applicationContext.xml)

<!-- 加载db.properties文件 -->
<bean  id="config" class="org.springframework.beans.factory.config.PreferencesPlaceholderConfigurer">
<property name="locations">
<array><value>classpath:db.properties</value></array>
</property>
</bean>
<!-- 引入service层的bean -->
<bean id="studentService" class="org.lanqiao.service.impl.StudentServiceImpl">
<property name="studentMapper" ref="studentMapper"></property>
</bean>
<!-- 配置配置数据库信息(替代mybatis的配置文件conf.xml) -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="${driver}"></property>
<property name="url" value="${url}"></property>
<property name="username" value="${username}"></property>
<property name="password" value="${password}"></property>
</bean>
<!-- 在SpringIoc容器中 创建MyBatis的核心类 SqlSesionFactory -->
<bean id="sqlSessionFacotry" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<!-- 加载mapper.xml路径 -->
<property name="mapperLocations" value="org/lanqiao/mapper/*.xml"></property>
</bean>

配置mapper中的sql语句
使用Spring-MyBatis整合产物开发程序

  1. DAO层实现类继承SqlSessionDaoSupport类
  2. 直接MyBatis提供的 Mapper实现类:org.mybatis.spring.mapper.MapperFactoryBean
<bean id="studentMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
<property name="mapperInterface" value="org.lanqiao.mapper.StudentMapper"></property>
<property name="sqlSessionFactory" ref="sqlSessionFacotry"></property>
</bean>
  1. 批量生成多个mapper
<!--Mapper对在SpringIOC中的id默认就是首字母小写接口名,service在ref对象要首字母小写-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="sqlSessionFactoryBeanName" value="sqlSessionFacotry"></property>
<!--指定批量产生 哪个包中的mapper对象-->
<property name="basePackage" value="org.lanqiao.mapper"></property>
</bean>

使用:

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
context.getBean("bean") ;

Spring-SpringMVC-MyBatis整合

引入jar包
配置类-表对应
配置Spring配置文件(applicationContext.xml):使用Spring整合MyBatis
编写springmvc配置文件:视图解析器、基础配置
配置mapper中的sql语句
配置Web配置文件

<!-- Web项目中,引入Spring -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 整合SPringMVC -->
<servlet>
<servlet-name>springDispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext-controller.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springDispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>

Springboot-JSP整合

新建boot项目war包
建立基本的web项目所需要的目录结构
webapps/WEB-INF(需要)
webapps/WEB-INF/web.xml (不需要)
webapps/index.jsp
创建tomcat实例并部署项目:如果是一个war包的spring boot项目,在启动服务器tomcat时,会自动调用ServletInitializer类中的configure方法,configure方法会调用spring boot的主配置类从而启动spring boot

Dubbo-SSM整合

创建父工程(引入公共依赖、实体类POJO依赖、module子模块依赖、解决Maven内置tomcat打包不引入xml问题的代码)
创建实体类(实体类需要implements Serializable接口)
创建公共模块实现接口共用(引入实体类POJO依赖、提供公共接口)
创建dao层(映射文件mapper、动态代理接口mapper、spring文件application(加载db文件、配置数据库信息、创建核心类sqlsessionfactory)、将核心类交给spring处理)
创建service层(补全WEB-INF/web.xml并拦截交给spring处理、pom依赖父工程+dao层+公共接口+tomcat代码、编写spring的application文件并顺带启动dao层spring的application、service的具体实现类)
创建显示web层(补全WEB-INF/web.xml并拦截交给springMVC处理、pom依赖父工程+公共接口+tomcat代码、编写控制器、配置sppringMVC)
其他
在maven中引入一个 mvn中央仓库中不存在的Jar:将jar自己安装到本地mvn仓库:cmd命令(ojdbc7.jar为例):mvn install:install-file -DgroupId=com.oracle -DartifactId=ojdbc7 -Dversion=10.2.0.5.0 -Dpackaging=jar -Dfile=f:\ojdbc7.jar
解决Maven内置tomcat打包不引入xml问题:

# 在父工程pom.xml的<project>元素中加入
  <build>
    	<resources> 
	  	<resource> 
	  	<directory>src/main/java</directory> 
	  	<includes> 
	  	<include>**/*.xml</include> 
	  	</includes> 
	  	<filtering>false</filtering>
		</resource> 
		<resource>
		<directory>src/main/resources</directory>
		</resource>
	</resources>
 </build>

Spring-Redis整合

建立java文件并引入jar包
指定连接 Redis 服务器的相关信息redis.properties(实现分配连接池和线程)
在spring的applicationContext配置文件中配置连接池、连接工厂和操作模板,并把RedisUtil加入bean中
使用工具类和测试类进行Redis的访问和检测

Spring-Quartz整合

引入jar包
创建实体类封装Job信息
创建实体类调用的具体方法
创建测试方法初始化容器和开始执行
创建配置文件applicationContext.xml

 <!--配置任务信息-->
    <bean id="scheduleJobEntity" class="com.yanqun.entity.ScheduleJob"  >
            <property name="jobId" value="j001"></property>
            <property name="jobName" value="任务1"></property>
            <property name="jobGroup" value="任务组1"></property>
            <property name="jobStatus" value="1"></property>
            <property name="cronExpression" value="5,10,30,50 * * * * ? *"></property>
            <property name="desc" value="描述..."></property>
    </bean>
    
<!--配置job类信息-->
    <bean  id="jobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean" >
            <property name="jobClass" value="com.yanqun.job.PlanJob"></property>
            <property name="jobDataAsMap">
                    <map>
                        <entry key="scheduleJob">
                            <ref bean="scheduleJobEntity"></ref>
                        </entry>
                    </map>
            </property>
    </bean>

<!-- cronTrigger触发器:定义时间规则
    <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">

            <property name="jobDetail" ref="jobDetail" >
            </property>
            <property name="cronExpression" value="#{scheduleJobEntity.cronExpression}">
            </property>
    </bean>-->
    
<!--SimpleTrigger触发器-->
    <bean  id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean"  >
            <property name="repeatInterval" value="2000"></property>
            <property name="repeatCount" value="10"></property>
            <property name="startDelay" value="3"></property>
            <property name="jobDetail" ref="jobDetail" ></property>
    </bean>
<!--配置调度器-->
      <bean id="schedulerFactoryBean"  class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
            <property name="triggers">
                <list>
                        <ref bean="simpleTrigger" />
                </list>
            </property>
      </bean>
  • 10
    点赞
  • 3
    评论
  • 95
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值