Java高级框架

< select id="" resultType="" >

WHERE id = #{param1} AND password = #{param2} <!--param1 param2 param3 ...-->

public User selectUserByIdAndPwd(@Param("id") Integer id , @Param("pwd") String pwd);

Map values = new HashMap(); //测试类创建Map

values.put("myId",1); //自定义key，绑定参数

values.put("myPwd","123456");

User user = userDao.selectUserByIdAndPwd_map(values);

SELECT * FROM t_users

WHERE id = #{myId} AND password = #{myPwd} <!-- 通过key获得value -->

public User selectUserByUserInfo(User user);

对象的名字和后面#{}括号中的一致

 SELECT * FROM t_users

WHERE name LIKE concat('%',#{keyword},'%') <!-- 拼接'%' -->

<selectKey keyProperty="id" resultType="int" order="AFTER"> <!-- 插入之后 -->

SELECT LAST_INSERT_ID() <!-- 适用于整数类型自增主键 -->

</selectKey>

SELECT REPLACE(UUID(),'-','') <!-- 适用于字符类型主键 -->

方案一：列的别名

方案二：结果映射（ResultMap - 查询结果的封装规则）

OneToOne：一对一关系（Passenger--- Passport）

OneToMany：一对多关系（Employee --- Department）

ManyToMany：多对多关系（Student --- Subject）

注意：指定“多方”关系时（集合），使用< collection ofType="" >

注意：指定“一方”关系时（对象），使用< association javaType="" >

案例

一方，添加集合；多方，添加对象。

双方均可建立关系属性，建立关系属性后，对应的Mapper文件中需使用< ResultMap >完成多表映射。

持有对象关系属性，使用< association property="dept" javaType="department" >

持有集合关系属性，使用< collection property="emps" ofType="employee" >

MyBatis的映射文件中支持在基础SQL上添加一些逻辑操作，并动态拼接成完整的SQL之后再执行，以达到SQL复用、简化编程的效果。

<sql>

<where>

<trim>

set

<foreach>

<if>

<delete>,<insert>,<update>

SqlSession级别的缓存，同一个SqlSession的发起多次同构查询，会将数据保存在一级缓存中。

注意：无需任何配置，默认开启一级缓存。

SqlSessionFactory级别的缓存，同一个SqlSessionFactory构建的SqlSession发起的多次同构查询，会将数据保存在二级缓存中。

注意：在sqlSession.commit()或者sqlSession.close()之后生效。

< settings >是MyBatis中极为重要的调整设置，他们会改变MyBatis的运行行为，其他详细配置可参考官方文档。

<settings>

<setting name="cacheEnabled" value="true"/> <!-- mybaits-config.xml中开启全局缓存（默认开启） -->

</settings>

<cache /> <!-- 指定缓存 -->

mybatis-config.xml中连接池相关配置。

- 注意：< property name="属性名" />属性名必须与com.alibaba.druid.pool.DruidAbstractDataSource中一致。

    <plugins>

<!-- com.github.pagehelper为PageHelper类所在包名 -->

<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>

</plugins>

UserDao userDao = MyBatisUtils.getMapper(UserDao.class);

PageHelper.startPage(1,2);//使用PageHelper设置分页条件

PageHelper中提供了多个分页操作的静态方法入口。

引入依赖

配置MyBatis-config.xml

<mappers>

<mapper class="com.qf.mybatis.part1.annotations.UserMapper" /><!-- class="接口全限定名"-->

</mappers>

public List<User> selectAllUsers1(User user); // ${name} ${id} 可获取user中的属性值

public List<User> selectAllUsers2(@Param("rule") String rule); //必须使用@Param否则会作为属性解析

实例

实用

SELECT * FROM t_user

WHERE name = '${name}' <!-- 会存在注入攻击 比如传入参数是 【String name = "tom' or '1'='1";】-->

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

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



</beans>

 public static void main(String[] args){

//1. 读取配置文件中所需创建的bean对象，并获得工厂对象

ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-context.xml");

//2. 通过id获取bean对象

MyClass mc = (MyClass) ctx.getBean("mc");

//3. 使用对象

mc.show();

}

<bean id="u1" class="com.qf.spring.part1.injection.User">

<!--base field-->

<property name="id" value="1001" />

<property name="password" value="123456" />

<property name="sex" value="male" />

<property name="age" value="20" />

<property name="bornDate" value="1990/1/1" /><!--注意格式"/"-->

</bean>

<bean id="u1" class="com.qf.spring.part1.injection.User">
<!--Array-->
<property name="hobbys">
<array>
<value>Run</value>
<value>Swim</value>
<value>Climb</value>
</array>
</property>
<!--Set-->
<property name="phones">
<set>
<value>13777777777</value>
<value>13888888888</value>
<value>13999999999</value>
</set>
</property>
<!--List-->
<property name="names">
<list>
<value>tom</value>
<value>jack</value>
<value>marry</value>
</list>
</property>
<!--Map-->
<property name="countries">
<map>
<entry key="CN" value="China" />
<entry key="US" value="America" />
<entry key="KR" value="Korea" />
</map>
</property>
<!--Properties-->
<property name="files">
<props>
<prop key="first">One</prop>
<prop key="second">Two</prop>
<prop key="third">Three</prop>
</props>
</property>
</bean>

形式一，实体类中有另个实体类属性

public class Student {

private Integer id;

private String name;

private String sex;

private Integer age;



//Constructors

public Student(Integer id , String name , String sex , Integer age){

this.id = id;

this.name = name;

this.sex = sex;

this.age = age;

}

}

 <!--构造注入-->

<bean id="u3" class="com.qf.zcg.spring.day1.t2.ioc.Student">

<constructor-arg name="id" value="1234" /> <!-- 除标签名称有变化，其他均和Set注入一致 -->

<constructor-arg name="name" value="tom" />

<constructor-arg name="age" value="20" />

<constructor-arg name="sex" value="male" />

</bean>

public class UserServiceImpl implements UserService {

private UserDAO userDAO；

//Getters And Setters
....
}

<bean id="userDao" class="com.qf.spring.part1.injection.UserDaoImpl" />

<!-- 为UserServiceImpl中的属性基于类型自动注入值 -->

<bean id="userService" class="com.qf.spring.part1.injection.UserServiceImpl" autowire="byType"></bean>

<bean id="userDao" class="com.qf.spring.part1.injection.UserDaoImpl" />

<!-- 为UserServiceImpl中的属性基于类型自动注入值 -->

<bean id="userService" class="com.qf.spring.part1.injection.UserServiceImpl" autowire="byName"></bean>

注意：isSingleton方法的返回值，需根据所创建对象的特点决定返回true/false。

例如：Connection 不应该被多个用户共享，返回false。

例如：SqlSessionFactory 重量级资源，不该过多创建，返回true。

初始化注解、销毁注解

单例bean：singleton

多例bean：prototype

代理类数量过多，不利于项目的管理。

多个代理类的辅助功能代码冗余，修改时，维护性差。

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>5.1.6.RELEASE</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-aspects</artifactId>

<version>5.1.6.RELEASE</version>

</dependency>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:aop="http://www.springframework.org/schema/aop"

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

http://www.springframework.org/schema/aop/spring-aop.xsd

">

</beans>

形成切面（Aspect）

前置通知：MethodBeforeAdvice



后置通知：AfterAdvice



后置通知：AfterReturningAdvice //有异常不执行，方法会因异常而结束，无返回值



异常通知：ThrowsAdvice



环绕通知：MethodInterceptor

<!-- public int com.qianfeng.service.UserServiceImpl.queryUser(int,String,com.entity.User) -->

<!--匹配参数-->

<aop:pointcut id="myPointCut" expression="execution(* *(com.qf.aaron.aop.basic.User))" />

<!--匹配方法名（无参）-->

<aop:pointcut id="myPointCut" expression="execution(* save())" />

<!--匹配方法名（任意参数）-->

<aop:pointcut id="myPointCut" expression="execution(* save(..))" />

<!--匹配返回值类型-->

<aop:pointcut id="myPointCut" expression="execution(com.qf.aaron.aop.basic.User *(..))" />

<!--匹配类名-->

<aop:pointcut id="myPointCut" expression="execution(* com.qf.aaron.aop.basic.UserServiceImpl.*(..))" />

<!--匹配包名-->

<aop:pointcut id="myPointCut" expression="execution(* com.qf.aaron.aop.basic.*.*(..))" />

<!--匹配包名、以及子包名-->

<aop:pointcut id="myPointCut" expression="execution(* com.qf.aaron.aop..*.*(..))" />

- spring中定义了很多后处理器；
- 每个bean在创建完成之前 ，都会有一个后处理过程，即再加工，对bean做出相关改变和调整；
- spring-AOP中，就有一个专门的后处理器，负责通过原始业务组件(Service),再加工得到一个代理组件。

/**

* 定义bean后处理器

* 作用：在bean的创建之后，进行再加工

*/

public class MyBeanPostProcessor implements BeanPostProcessor{



/**

* 在bean的init方法之前执行

* @param bean 原始的bean对象

* @param beanName

* @return

* @throws BeansException

*/

public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

System.out.println("后处理器 在init之前执行~~~"+bean.getClass());

return bean;

}

/**

* 在bean的init方法之后执行

* @param bean postProcessBeforeInitialization返回的bean

* @param beanName

* @return

* @throws BeansException

*/

@Override

public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

System.out.println("后处理器 在init之后执行~~~"+bean.getClass());

return bean;// 此处的返回是 getBean() 最终的返回值

}

}

<!-- 配置后处理器,将对工厂中所有的bean声明周期进行干预 -->

<bean class="com.qianfeng.beanpostprocessor.MyBeanPostProcessor"></bean>

构造 》 注入属性 满足依赖 》 后处理器前置过程 》 初始化 》后处理器后置过程 》 返回 》 销毁

// AbstractAutoProxyCreator是 AspectJAwareAdvisorAutoProxyCreator的父类

// 该后处理器类中的 wrapIfNecessary方法即动态代理生成过程

AbstractAutoProxyCreator#postProcessAfterInitialization(Object bean, String beanName){

if (!this.earlyProxyReferences.contains(cacheKey)) {

// 开始动态定制代理

return wrapIfNecessary(bean, beanName, cacheKey);

}

}

 <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">



<property name="driverClassName" value="${jdbc.driver}"/>

<property name="password" value="${jdbc.password}"/>

<property name="url" value="${jdbc.url}"/>

<property name="username" value="${jdbc.username}"/>



<!-- 配置初始化大小、最小、最大 -->

<property name="initialSize" value="1"/>

<property name="minIdle" value="1"/>

<property name="maxActive" value="3"/>



<!-- 配置获取连接等待超时的时间 -->

<property name="maxWait" value="60000"/>



<!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->

<property name="timeBetweenEvictionRunsMillis" value="60000"/>



<!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->

<property name="minEvictableIdleTimeMillis" value="300000"/>

</bean>

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">

<!-- 连接池 -->

<property name="dataSource" ref="dataSource"/>



<!-- 注册mapper -->

<property name="mapperLocations" value="classpath:mapper/*.xml"/>



<!-- 别名 -->

<property name="typeAliasesPackage" value="com.qianfeng.entity"/>



</bean>

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">



<property name="basePackage" value="com.qianfeng.dao"/>



<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>

</bean>



<!-- Service -->

<bean id="orderService" class="com.qianfeng.service.OrderServiceImpl">

<property name="orderDAO" ref="orderDAO"/>

</bean>

<!-- 事务管理器 -->

<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<property name="dataSource" ref="dataSource"/>



</bean>

<!-- 事务增强(Advice) -->

<tx:advice id="txAdvice" transaction-manager="txManager" >

<!-- 为需要事务的方法 设置事务属性 -->

<tx:attributes>

<tx:method name="queryUser" propagation="SUPPORTS" read-only="true"/>

<tx:method name="insertUser" propagation="REQUIRED" read-only="false" rollback-for="Exception"/>

</tx:attributes>

</tx:advice>

<!-- 编织： 组装 -->

<aop:config>

<aop:pointcut id="tx_pc" expression="execution(* queryUser(..))"/>

<aop:pointcut id="tx_p1" expression="execution(* *(com.qf.entiy.User))"/>

<aop:advisor advice-ref="txAdvice" pointcut-ref="tx_pc"/>

<aop:advisor advice-ref="txAdvice" pointcut-ref="tx_p1"/>

</aop:config>

#jdbc.properties

jdbc.driverClass=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql://localhost:3306/mydb?useUnicode=true&characterEncoding=UTF-8

jdbc.username=root

jdbc.password=123456

default

(默认值）（采用数据库的默认的设置) （建议）

read-uncommited

读未提交

read-commited

读提交 （Oracle数据库默认的隔离级别）

repeatable-read

可重复读 （MySQL数据库默认的隔离级别）

serialized-read

序列化读

- 安全性：级别越高，多事务并发时，越安全。因为共享的数据越来越少，事务间彼此干扰减少。
- 并发性：级别越高，多事务并发时，并发越差。因为共享的数据越来越少，事务间阻塞情况增多。

事务并发时的安全问题

脏读

一个事务读取到另一个事务还未提交的数据。大于等于 read-commited 可防止

不可重复读

一个事务内多次读取一行数据的相同内容，其结果不一致。大于等于 repeatable-read 可防止

幻影读

一个事务内多次读取一张表中的相同内容，其结果不一致。serialized-read 可防止

@RunWith(SpringJUnit4ClassRunner.class) //由SpringJUnit4ClassRunner启动测试

@ContextConfiguration("classpath:applicationContext.xml") //spring的配置文件位置

public class SpringTest{//当前测试类也会被纳入工厂中，所以其中属性可以注入



@Autowired // 注入要测试的组件

@Qualifier("userDAO")

private UserDAO userDAO;



@Test

public void test(){

// 测试使用userDAO

userDAO.queryUser();

....

}

}

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">

<!-- localRepository

| The path to the local repository maven will use to store artifacts.

|

| Default: ${user.home}/.m2/repository

<localRepository>/path/to/local/repo</localRepository>

-->

<!-- 选择一个磁盘目录，作为本地仓库 -->

<localRepository>D:\Program Files\maven\myrepository</localRepository>

<profiles>

<!-- 在已有的profiles标签中添加profile标签 -->

<profile>

<id>myjdk</id>

<activation>

<activeByDefault>true</activeByDefault>

<jdk>1.8</jdk>

</activation>

<properties>

<maven.compiler.source>1.8</maven.compiler.source>

<maven.compiler.target>1.8</maven.compiler.target>

<maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>

</properties>

</profile>

</profiles>

<!-- 让增加的 profile生效 -->

<activeProfiles>

<activeProfile>myjdk</activeProfile>

</activeProfiles>

中央仓库在国外，下载依赖速度过慢，所以都会配置一个国内的公共仓库替代中央仓库。

除中央仓库之外，还有其他远程仓库。比如aliyun仓库（http://maven.aliyun.com/nexus/content/groups/public/）

<!--settings.xml中添加如下配置-->

<mirrors>

<mirror>

<id>aliyun</id>

<!-- 中心仓库的 mirror(镜像) -->

<mirrorOf>central</mirrorOf>

<name>Nexus aliyun</name>

<!-- aliyun仓库地址 以后所有要指向中心仓库的请求，都会指向aliyun仓库-->

<url>http://maven.aliyun.com/nexus/content/groups/public</url>

</mirror>

</mirrors>

概念

启动

执行 git status 可以看到工作区中文件的状态

执行 git add . 将工作区中的文件全部存入暂存区

执行 git add 文件名

执行 git commit -m "这里写提交的描述信息" 作用是将暂存区的文件存入分支，形成一个版本

1.关联仓库地址

2.git push origin master

如果仓库已经由别人创建完毕，我们需要其中的内容，则可以通过 git clone 将其复制到本地。

多人协同开发时，写好代码的git push 上传到远程仓库；需要代码的 git pull 拉取代码即可。

查看当前仓库的分支 git branch

仓库中默认只有 master 分支

执行git commit时，默认是在master分支上保存版本。

在商业项目开发过程中，我们不会轻易的在master分支上做操作。

我们会新建一个开发用的分支，在此分支上做版本的记录。

当代码确实没有问题时，才会将开发分支上成熟的代码版本添加到master分支上。

当代码确实没有问题时，才会将开发分支上成熟的代码版本添加到master分支上。

默认情况下，当前使用的分支是 master分支

可以切换到 dev分支，则后续的git commit 便会在dev分支上新建版本(提交点)

在master分支和新分支，分别进行 git add 和 git commit

HEAD指向的是当前分支

当前分支合并分支a

快速合并

三方合并

合并冲突

@Controller //声明这是一个控制器

@RequestMapping("/hello") //访问路径 ，等价于url-pattern

public class HelloController {

@RequestMapping("/test1") //访问路径

public String hello1(){

System.out.println("hello world");

return "index"; // 跳转:/index.jsp

}

@RequestMapping("/test2") //访问路径

public String hello2(){

System.out.println("hello c9");

return "views/users";// 跳转:/views/user.jsp

}

}

<form>

......

<input type="checkbox" name="hobby" value="fb"/>足球

<input type="checkbox" name="hobby" value="bb"/>篮球

<input type="checkbox" name="hobby" value="vb"/>排球



</form>

//http://localhost:8989/.../test3?hobby=football&hobby=basketball

@RequestMapping("/test3")

public String testParam3(String[] hobby){

for(String h:hobby){

System.out.print(h+" ");

}

return "index";

}

数据存入request域中但是，如果用HttpServletRequest存的话优先级要比model低，model会覆盖它

//modelandview 可以集中管理 跳转和数据

@RequestMapping("/test")

public ModelAndView testData(){//返回值类型为ModelAndView

//新建ModelAndView对象

ModelAndView mv = new ModelAndView();

// 设置视图名，即如何跳转

mv.setViewName("forward:/index.jsp");

// 增加数据

mv.addObject("age",18);

return mv;

}



//jsp中用EL表达式 取值即可

${requestScope.age}

数据都是存入request域中

@Controller

@SessionAttributes({"gender","name"}) // model中的 name和gender 会存入session中

public class UserController {



@RequestMapping("/hello")

public String hello(Model m){

m.addAttribute("gender",true); // 会存入session

mv.addObject("name","zhj"); // 会存入session

return "index";

}



@RequestMapping("/hello2")

public String hello(SessionStatus status){

// 移除通过SessionAttributes存入的session

status.setComplete();

return "index";

}

}

<servlet-mapping>

<servlet-name>mvc9</servlet-name>

<url-pattern>*.action</url-pattern>

</servlet-mapping>

<!--

额外的增加一个handler，且其requestMapping: "/**" 可以匹配所有请求，但是优先级最低

所以如果其他所有的handler都匹配不上，请求会转向 "/**" ,恰好，这个handler就是处理静态资源的

处理方式：将请求转会到tomcat中名为default的Servlet

-->

<mvc:default-servlet-handler/>

<mvc:resources mapping="/html/**" location="/hhh/"/>

<!-- Jackson springMVC默认的Json解决方案选择是 Jackson，所以只需要导入jackson的jar，即可使用。-->

<dependency>

<groupId>com.fasterxml.jackson.core</groupId>

<artifactId>jackson-databind</artifactId>

<version>2.9.8</version>

</dependency>

@ResponseBody

@RestController

@RequestBody

@PathVariable

常用注解

<!-- FastJson -->

<dependency>

<groupId>com.alibaba</groupId>

<artifactId>fastjson</artifactId>

<version>1.2.54</version>

</dependency>

<mvc:annotation-driven>

<!-- 安装FastJson,转换器 -->

<mvc:message-converters>

<bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">

<!-- 声明转换类型:json -->

<property name="supportedMediaTypes">

<list>

<value>application/json</value>

</list>

</property>

</bean>

</mvc:message-converters>

</mvc:annotation-driven>

@ResponseBody @RequestBody @RestController 使用方法不变

常用注解

<script>

function submit2004(){

var size = document.getElementById("up2004").files[0].size;

if(size/1024/1024>2){

alert("文件不能大于2M");

return;

}

document.forms[0].submit();

}

</script>

<!-- 上传解析器 -->

<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">

<!-- 最大值给一个 很大的数字，让上传解析器不再限制大小 -->

<property name="maxUploadSize" value="2097152000000"/>

</bean>

所有用户

查询用户1

查询用户1下的所有订单

http://localhost:8989/xxx/users

http://localhost:8989/xxx/users

http://localhost:8989/xxx/users

http://localhost:8989/xxx/users/1

http://localhost:8989/xxx/users/1

http://localhost:8989/xxx/users/1/orders

http://localhost:8989/xxx/users/1/orders

@RequestMapping(value="/users",method = RequestMethod.GET)

等价

@GetMapping("/users")

- DispatcherServlet 启动的springMVC工厂==负责生产C及springMVC自己的系统组件
- ContextLoaderListener 启动的spring工厂==负责生产其他所有组件
- springMVC的工厂会被设置为spring工厂的子工厂，可以随意获取spring工厂中的组件
- 整合过程，就是累加：代码+依赖+配置。然后将service注入给controller即可

<!-- 告知SpringMVC 哪些包中 存在 被注解的类

use-default-filters=true 凡是被 @Controller @Service @Repository注解的类，都会被扫描

use-default-filters=false 默认不扫描包内的任何类, 只扫描include-filter中指定的类

只扫描被@Controller注解的类

-->

<context:component-scan base-package="com.zhj" use-default-filters="false">

<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>

</context:component-scan>

<!-- 告知Spring

唯独不扫描@Controller注解的类 -->

<context:component-scan base-package="com.zhj" use-default-filters="true">

<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>

</context:component-scan>

//创建scheduler，调度器

Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

//定义一个Trigger,触发条件类

Trigger trigger = TriggerBuilder.newTrigger()

.withIdentity("trigger1", "group1") //定义name/group

.startNow()//一旦加入scheduler，立即生效，即开始计时

.withSchedule(SimpleScheduleBuilder.simpleSchedule()

.withIntervalInSeconds(1) //每隔一秒执行一次

.repeatForever()) //一直执行，直到结束时间

.endAt(new GregorianCalendar(2019,7,15,16,7,0).getTime())//设置结束时间

.build();

//定义一个JobDetail

//定义Job类为HelloQuartz类，这是真正的执行逻辑所在

JobDetail job = JobBuilder.newJob(HelloQuartz.class)

.withIdentity("job1","group1") //定义name/group

.build();

//调度器 中加入 任务和触发器

scheduler.scheduleJob(job, trigger);

//启动任务调度

scheduler.start();   

指定起始和截止时间(时间段)

指定时间间隔、执行次数

// 每天10:00-12:00，每隔2分钟执行一次

CronTrigger trigger = TriggerBuilder.newTrigger()

.withIdentity("t1", "g1")

.withSchedule(CronScheduleBuilder.cronSchedule("0 0/2 10-12 * * ?")).build(); 

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

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



<!--

Spring整合Quartz进行配置遵循下面的步骤：

1：定义工作任务的Job

2：定义触发器Trigger，并将触发器与工作任务绑定

3：定义调度器，并将Trigger注册到Scheduler

-->



<!-- 1：定义任务的bean ，这里使用JobDetailFactoryBean,也可以使用MethodInvokingJobDetailFactoryBean ，配置类似-->

<bean name="lxJob" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">

<!-- 指定job的名称 -->

<property name="name" value="job1"/>

<!-- 指定job的分组 -->

<property name="group" value="job_group1"/>

<!-- 指定具体的job类 -->

<property name="jobClass" value="com.qf.quartz.MyJob"/>

</bean>



<!-- 2：定义触发器的bean，定义一个Cron的Trigger，一个触发器只能和一个任务进行绑定 -->

<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">

<!-- 指定Trigger的名称 -->

<property name="name" value="trigger1"/>

<!-- 指定Trigger的名称 -->

<property name="group" value="trigger_group1"/>

<!-- 指定Tirgger绑定的JobDetail -->

<property name="jobDetail" ref="lxJob"/>

<!-- 指定Cron 的表达式 ，当前是每隔5s运行一次 -->

<property name="cronExpression" value="*/5 * * * * ?" />

</bean>



<!-- 3.定义调度器，并将Trigger注册到调度器中 -->

<bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">

<property name="triggers">

<list>

<ref bean="cronTrigger"/>

</list>

</property>

<!-- 添加 quartz 配置，如下两种方式均可 -->

<!--<property name="configLocation" value="classpath:quartz.properties"></property>-->

<property name="quartzProperties">

<value>

# 指定调度器名称，实际类型为：QuartzScheduler

org.quartz.scheduler.instanceName = MyScheduler

# 指定连接池

org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool

# 连接池线程数量

org.quartz.threadPool.threadCount = 11

# 优先级

org.quartz.threadPool.threadPriority = 5

# 不持久化job

org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

</value>

</property>

</bean>

</beans>

工厂启动，调度器启动，任务调度开始

public static void main(String[] args) throws InterruptedException, SchedulerException {

// 工厂启动，任务启动，工厂关闭，任务停止

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

}

删除任务

暂停、恢复