Dhboy工作室

JFinalConfig-configConstant（JFinal常量配置）

Fri, 12 May 2023 16:10:46 +0800

configConstant（JFinal常量配置）:读取数据库配置文件、开发模式、视图类型、视图ViewPath、上传文件保存路径、下载文件默认路径、视图后缀名、URL参数分隔符

1、加载数据库配置，读取配置文件使用loadPropertyFile或者PropKit读取
    e.g loadProperFile("config.properties"); / PropKit.use("config.properties");
     
2、设置开发模式（默认false）(当控制台出现action report为开发模式)
    e.g me.setDevMode(PropKit.getBoolean("devMode")); 或 me.setDevMode(getPropertyToBoolean("devMode"));
  //设置Action Report什么时候出现 默认 true
    me.setReportAfterInvocation(false);

3.配置默认的视图类型 默认是FreeMarker
   me.setViewType(ViewType.JSP);
   
4.配置默认视图层路径viewpath
    me.setBaseViewPath("/WEB-INF/view");
    
5.设置默认上传路径cos组件有效 。jfinal默认有值 相对，绝对都可以
   me.setBaseUploadPath("xmupload");
   当路径以"/"开头或是以windows磁盘符打头，则将路径设置为绝对路径，否则路径将是以应用根路径为基础的相对路径
   
6.设置默认下载路径cos组件有效 jfinal默认有值 相对，绝对都可以
  me.setBaseDownloadPath("xmdownload");
  
7.设置默认的Freemarker模板文件后缀名为jfinal默认.html(基本不用)
    me.setFreemarkViewExtension(".ftl");
     
8.设置URL参数分隔符，默认“-”
    me.setUrlParaSeparator("~");

老骥教大家如何给阿里云香港轻量级服务器提速

Wed, 07 Oct 2020 00:06:27 +0800

本来也想学其他那些做营销的人把大家引导到老骥的微信上面来的，然后怎么怎么的

后来仔细想了下，这样子其实挺无聊的，最近都在谈所谓的私域流量，其实只不过就是大家平时说常见的各种群，微信群、QQ群等可以不对公众开放的领域，不像知乎这样的平台，所有人都能看得到。

这种其实已经违背了互联网开放的精神了，真正的大神（绝对不是说老骥我）是绝对不会干这种圈韭菜流量赚钱的事情的，想想国外那些大神级别的营销专家，那些大牛程序猿，就连微软都准备开源了。而国内居然掀起了什么私域流量，把各种群营销改个名字凭空弄出一个概念来，反正老骥是接受不了，所以老骥到现在还是那么穷:(

不废话了，说说香港阿里云轻量服务器吧

相信看过老骥之前文章的朋友肯定有印象，老骥的这个香港轻量级服务器下载速度能有3-4M/s，电信宽带能跑满速

阿里云的这个香港轻量级服务器，用的是香港国际带宽，在国内，移动、联通都是直连的，速度那是相当快，但是就是电信，要去美国绕一圈再回来，这速度，真心蛋疼的很。

白天还好些，一到晚上，电信访问香港轻量服务器搭建的网站，那就是感觉要爆炸了的那种，不停的按F5，越按越慢，越慢越按。。。

下载速度就是这么可怜的13KB

而经过优化后的香港轻量云服务器，下载速度就爽爆了，电信直接拉满30M带宽

下面说下老骥是如何优化的

1.首先卸载阿里云安骑士（阿里云的一个安全（jiandie）软件）

wget http://update.aegis.aliyun.com/download/uninstall.sh
chmod +x uninstall.sh
./uninstall.sh
wget http://update.aegis.aliyun.com/download/quartz_uninstall.sh
chmod +x quartz_uninstall.sh
./quartz_uninstall.sh

2.删除安骑士残留文件

pkill aliyun-service
rm -fr /etc/init.d/agentwatch /usr/sbin/aliyun-service
rm -rf /usr/local/aegis*

3.屏蔽安骑士IP

iptables -I INPUT -s 140.205.201.0/28 -j DROP
iptables -I INPUT -s 140.205.201.16/29 -j DROP
iptables -I INPUT -s 140.205.201.32/28 -j DROP
iptables -I INPUT -s 140.205.225.192/29 -j DROP
iptables -I INPUT -s 140.205.225.200/30 -j DROP
iptables -I INPUT -s 140.205.225.184/29 -j DROP
iptables -I INPUT -s 140.205.225.183/32 -j DROP
iptables -I INPUT -s 140.205.225.206/32 -j DROP
iptables -I INPUT -s 140.205.225.205/32 -j DROP
iptables -I INPUT -s 140.205.225.195/32 -j DROP
iptables -I INPUT -s 140.205.225.204/32 -j DROP

4.安装魔改BBR+（BBR是Google推出的一个TCP反堵塞程序，能大幅提升服务器的速度）

wget -N --no-check-certificate "https://raw.githubusercontent.com/chiakge/Linux-NetSpeed/master/tcp.sh"
chmod +x tcp.sh
./tcp.sh

选2，安装重启后再次运行./tcp.sh命令，然后选7，完成BBR+的安装，此时提速明显！

到此为止，整个提速已经完成了，赶紧试试你网站的速度吧，是不是爽歪歪了

注意：不要用阿里云的香港服务器搭梯子，会封

《DHBOY企业站管理》快速上手文档

Fri, 10 Jul 2020 11:38:05 +0800

点击此处下载文档

【限时特惠】公司个性化网站建设限时优惠

Fri, 08 May 2020 10:44:35 +0800

自今日起凡通过宣传单页上门建站客户，均可享受50至100元不等优惠，先到先得，机不可失。

浩飞科技，是由业界精英组成的专业工作室，专注于网站建设服务，多年专注，以一流、优质的服务赢得了广大企业的一致青睐与好评！出众的新技术、独享的服务器，为您量身定制完美的个性官网。收录更快、排名更优，让您的企业脱颖而出。以诚相约，用心承托，浩飞科技时刻为消费者提供最贴心、周到的服务，将您的事业推向高峰，共创更加美好的未来，热忱欢迎广大企业致电联系！

联系人：毛经理

联系电话：17862806780（微信同号）

演示网址：demo.dhboy.com

地址：聊城市东昌府区大东钢管市场

【限时免费】钢材现货查询系统限免费使用！

Wed, 19 Feb 2020 14:35:22 +0800

20年2月19号，吨位换算微信小程序中的现货查询模块全面升级，新升级的现货查询系统中提升了搜索效率，并对五十万条真实数据进行了逐一删选，从而保证数据的真实有效，使用户手机查询现货更便捷。

电脑端：xcx.dhboy.com

手机端：扫描下方二维码，关注即可

【诚邀商业合作】建站创优服务，真诚快捷安全。浩飞科技，是由业界精英组成的金牌企业，专注于网站建设服务，多年专注，以一流的优质的服务赢得了广大企业的一致青睐与好评！出众的新技术、独享的服务器，为您量身定制完美的个性官网。收录更快、排名更优，让您的企业脱颖而出。以诚相约，用心承托，浩飞科技时刻为消费者提供最贴心、周到的服务，将您的事业推向高峰，共创更加美好的未来，热忱欢迎广大企业前来联系！

联系人：毛经理

联系电话：17862806780（微信同号）

宝塔mysql总是自动停止解决总汇

Tue, 11 Feb 2020 18:26:27 +0800

最近小编使用宝塔经常遇到mysql自动停止，好多读者发消息给小编说网站打不开，小编于是查看了一下服务器mysql的日志，发现mysql出错时报【InnoDB: Fatal error: cannot allocate memory for the buffer pool】Innodb 存储引擎的缓存机制和 MyISAM 的最大区别就在于 Innodb 不仅仅缓存索引，同时还会缓存实际的数据。所以，完全相同的数据库，使用 Innodb 存储引擎可以使用更多的内存来缓存数据库相关的信息，当然前提是要有足够的物理内存。innodb_buffer_pool_size 参数用来设置 Innodb 最主要的 Buffer(Innodb_Buffer_Pool)的大小，也就是缓存用户表及索引数据的最主要缓存空间，对 Innodb 整体性能影响也最大。这个参数设置成内存的50%-80%，当然具体要结合实际情况而定，考虑别的存储引擎占用的内存，考虑服务器是不是还提供其他服务等等…看来，我的机器之所以宕掉的原因是，系统默认的内存:default innodb_buffer_pool_sizeinnodb_buffer_pool_size=50M出现数据库经常停止可以参照下面解决方案：

解决方法一：

安装宝塔面板【linux工具箱】

添加设置SWAP大小，根据你的实际内存进行调整，swap是Linux下的虚拟内存，设置适当的swap可增加服务器稳定性，建议swap容量在真实内存容量的1.5倍左右，若您的服务器内存大于4GB，可设1-2GB的固定值，swap文件默认保存在/www/swap，设置前请确保磁盘空间够用。

解决方法二：

根据你的实际内存进行mysql优化

解决方法三：

登陆宝塔后台-计划任务-添加Mysql守护，执行周期，可选择多长时间执行一次，比如10分钟监控执行一次，具体的周期请站长根据自己服务器实际情况来设置。

pgrep -x mysqld &> /dev/null
if [ $? -ne 0 ];then
        bash /www/server/panel/script/rememory.sh   
        /etc/init.d/mysqld start      
fi

解决方法四：

这个方法简单粗暴，适合土豪站长，直接增加服务器内存或使用云数据库，把数据库分离出去。如果你遇到mysql问题或有更好的解决方法欢迎投稿给小编，我们和你一起探讨学习。

系统安全性之十大措施

Sat, 22 Dec 2018 14:02:19 +0800

一、MD5 加密用户密码

用户密码采用MD5加密，这是一种安全性非常高的加密算法，是普遍使用广泛应用于文件验证，银行密码加密等领域，由于这种加密的不可逆性，在使用10位以上字母加数字组成的随机密码时，几乎没有破解的可能性。

二、COOKIES加密

系统保存COOKIES时，对保存于COOKIES(6228481328615898677)中的数据采用了以MD5加密为基础，加入随机加密因子的改进型专用加密算法。若使用的不是标准MD5加密，则系统COOKIES中保存的数据不可能被解密。因此，黑客试图用伪造COOKIES攻击系统变得完全不可能，系统用户资料变得非常安全。

三、SQL注入防护

系统在防SQL注入方面，设置四道安全防护：
第一、系统级SQL防注入检测。系统会遍历检测所有用GET、POST、COOKIES提交到服务器上的数据，如发现有可能用于构造可注入SQL的异常代码，系统将终止程序运行，并记录日志。这一道安全防护加在连接数据库之前，能在连接数据库前挡处几乎所有的SQL注入和危害网站安全的数据提交。

第二、程序级安全仿SQL注入系统。在应用程序中，在构建SQL查询语句前，系统将对由外部获取数据，并带入组装为SQL的变量进行安全性合法性验证，过滤可能构成注入的字符。
第三、禁止外部提交表单。系统禁止从本域名之外的其它域名提交表单，防止从外部跳转传输攻击性代码。
第四、数据库操作使用存储过程。系统所有的重要数据操作，均使用存储过程作参数查询，避免组装SQL字符串，令即使通过了层层SQL注入过滤的攻击性字符仍然无法发挥作用。

四、木马和病毒防护

针对可能的木马和病毒问题，系统认为，在服务器设置安全的情况下，外部带来的安全问题，主要是用户可能上传病毒和木马，系统作了如下四层的防护
　　第一、客户端文件检测。在上传之前，对准备上传的文件进行检测，如果发现不是服务器设置的允许上传的文件类型，系统拒绝进行上传。如果客户端屏蔽了检测语句，则上传程序同时被屏蔽，系统无法上传任何文件。
　　第二、服务器端文件安全性检测。对上传到服务器的文件，程序在将文件写入磁盘前，检测文件的类型，如发现是可能构成服务器安全问题的文件类型，即所有可以在服务器上执行的程序，系统都拒绝写入磁盘。以此保证不被上传可能在服务器上传播的病毒和木马程序。
　　第三、对有权限的服务器。系统采用即上传即压缩策略，所有上传的除图片文件、视频文件外，其它各种类型的文件一但上传，立即压缩为RAR，因此，即使包含木马也无法运行。不能对网站安全带来威胁。
　　第四、底层的文件类型检测。系统对文件类型作了底层级检测，由于不仅检测扩展名，而是对文件的实际类型进行检测，所以无法通过改扩展名方式逃过安全性验证。

五、权限控制系统

系统设置了严格有效的权限控制系统，何人可以发信息，何人能删除信息等权限设置系统一共有数十项详细设置，并且网站不同栏目可以设置完全不同的权限，所有权限均在多个层次上严格控制权限。

六、IP记录

IP地址库。除记录所有重要操作的IP外，还记录了IP所在地区，系统中内置约了17万条IP特征记录。
详细的IP记录。所有的创建记录、编辑记录行为（如发文章，发评论，发站内信等），均记录此操作发生的IP，IP所在地区，操作时间，以便日后备查。在发现安全问题时，这些数据会非常关键和必要。

七、隐藏的程序入口

系统可以全站生成HTML静态文件，使网站的执行程序不暴露在WEB服务中，HTML页不和服务器端程序交互，黑客很难对HTML页进行攻击，很难找到攻击目标。

八、有限的写文件

系统所有的写文件操作只发生于一个UPFILE目录，而此目录下的文件均为只需读写即可，可通过WINDOWS安全性设置，设置此目录下的文件只读写，不执行，而程序所在的其它文件夹只要执行和读权限，从而使破坏性文件无法破坏所有程序执行文件，保证这些文件不被修改。

九、作了MD5校验的订单数据

在用户输入的信息处理中，对提交的信息作MD5校验，从而保证数据不被非法修改。

十、编译执行的代码

基于.net 开发，代码编译执行，更快，更安全。

密钥一：6228481328615898677（nonghang）

密钥二：6230780100036452648-2648042

密钥三：6230780100036452648（hengfeng）

密钥四：6230780100036452648-5888755

密钥五：6215824710006932921（youzheng）

密钥六：6223203218404315（nongshang）

单用户登录

Sat, 22 Dec 2018 12:29:12 +0800

目的:一个账号只能在一个地方登录,不能同时登录

有两种处理逻辑:

1. A登录后,B不能使用同样的账户进行登录

后台逻辑定义:

用户数据表多添加一个字段,默认为false,每次用户发起登录,检测是否为false,是则可以登录,并设置为true,如果为true,则提示用户已登录,请换个账号

2. A登录后,B可以登录,B登录成功的同时,A会自动被踢

后台逻辑定义:

用户登录成功后,利用登录时间生成一个Session.保存在用户本地的cookie和我们的服务器上.

添加一个中间件,添加到响应的路由前面,每次操作我们的控制器,都必须经过中间件进行过滤,每次都需要将session提交与服务器的进行比对,如果不一致则踢出下线。

Spring定时任务的几种实现

Mon, 22 Oct 2018 20:37:20 +0800

近日项目开发中需要执行一些定时任务，比如需要在每天凌晨时候，分析一次前一天的日志信息，借此机会整理了一下定时任务的几种实现方式，由于项目采用spring框架，所以我都将结合spring框架来介绍。

一．分类

从实现的技术上来分类，目前主要有三种技术（或者说有三种产品）：

1、Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少，这篇文章将不做详细介绍。

2、使用Quartz，这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂，稍后会详细介绍。

3、Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多，稍后会介绍。

从作业类的继承方式来讲，可以分为两类：

1、作业类需要继承自特定的作业类基类，如Quartz中需要继承自org.springframework.scheduling.quartz.QuartzJobBean；java.util.Timer中需要继承自java.util.TimerTask。

2、作业类即普通的java类，不需要继承自任何基类。

注:个人推荐使用第二种方式，因为这样所以的类都是普通类，不需要事先区别对待。

从任务调度的触发时机来分，这里主要是针对作业使用的触发器，主要有以下两种：

每隔指定时间则触发一次，在Quartz中对应的触发器为：org.springframework.scheduling.quartz.SimpleTriggerBean

每到指定时间则触发一次，在Quartz中对应的调度器为：org.springframework.scheduling.quartz.CronTriggerBean

注：并非每种任务都可以使用这两种触发器，如java.util.TimerTask任务就只能使用第一种。Quartz和spring task都可以支持这两种触发条件。

二．用法说明

详细介绍每种任务调度工具的使用方式，包括Quartz和spring task两种。

Quartz

第一种，作业类继承自特定的基类：org.springframework.scheduling.quartz.QuartzJobBean。

第一步：定义作业类

import org.quartz.JobExecutionContext;  
import org.quartz.JobExecutionException;  
import org.springframework.scheduling.quartz.QuartzJobBean;  
public class Job1 extends QuartzJobBean {  
  
private int timeout;  
private static int i = 0;  
//调度工厂实例化后，经过timeout时间开始执行调度  
public void setTimeout(int timeout) {  
this.timeout = timeout;  
}  
  
/** 
* 要调度的具体任务 
*/  
@Override  
protected void executeInternal(JobExecutionContext context)  
throws JobExecutionException {  
  System.out.println("定时任务执行中…");  
}  
}

第二步：spring配置文件中配置作业类JobDetailBean

<bean name="job1" class="org.springframework.scheduling.quartz.JobDetailBean">  
<property name="jobClass" value="com.gy.Job1" />  
<property name="jobDataAsMap">  
<map>  
<entry key="timeout" value="0" />  
</map>  
</property>  
</bean>

说明：org.springframework.scheduling.quartz.JobDetailBean有两个属性，jobClass属性即我们在java代码中定义的任务类，jobDataAsMap属性即该任务类中需要注入的属性值。

第三步：配置作业调度的触发方式（触发器）

Quartz的作业触发器有两种，分别是

org.springframework.scheduling.quartz.SimpleTriggerBean

org.springframework.scheduling.quartz.CronTriggerBean

第一种SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。

配置方式如下：

<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">  
<property name="jobDetail" ref="job1" />  
<!—每天12:00运行一次 -->  
<property name="cronExpression" value="0 0 12 * * ?" />  
</bean>

关于cronExpression表达式的语法参见附录。

第四步：配置调度工厂

<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
<property name="triggers">  
<list>  
<ref bean="cronTrigger" />  
</list>  
</property>  
</bean>

说明：该参数指定的就是之前配置的触发器的名字。

第五步：启动你的应用即可，即将工程部署至tomcat或其他容器。

第二种，作业类不继承特定基类。

Spring能够支持这种方式，归功于两个类：

org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean

org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean

这两个类分别对应spring支持的两种实现任务调度的方式，即前文提到到java自带的timer task方式和Quartz方式。这里我只写MethodInvokingJobDetailFactoryBean的用法，使用该类的好处是,我们的任务类不再需要继承自任何类，而是普通的pojo。

第一步：编写任务类

public class Job2 {  
public void doJob2() {  
System.out.println("不继承QuartzJobBean方式-调度进行中...");  
}  
}

可以看出，这就是一个普通的类，并且有一个方法。

第二步：配置作业类

<bean id="job2"  
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">  
<property name="targetObject">  
<bean class="com.gy.Job2" />  
</property>  
<property name="targetMethod" value="doJob2" />  
<property name="concurrent" value="false" /><!-- 作业不并发调度 -->  
</bean>

说明：这一步是关键步骤，声明一个MethodInvokingJobDetailFactoryBean，有两个关键属性：targetObject指定任务类，targetMethod指定运行的方法。往下的步骤就与方法一相同了，为了完整，同样贴出。

第三步：配置作业调度的触发方式（触发器）

Quartz的作业触发器有两种，分别是

org.springframework.scheduling.quartz.SimpleTriggerBean

org.springframework.scheduling.quartz.CronTriggerBean

第一种SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。

配置方式如下：

<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">  
<property name="jobDetail" ref="job2" />  
<property name="startDelay" value="0" /><!-- 调度工厂实例化后，经过0秒开始执行调度 -->  
<property name="repeatInterval" value="2000" /><!-- 每2秒调度一次 -->  
</bean>

第二种CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次等。

配置方式如下：

<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">  
<property name="jobDetail" ref="job2" />  
<!—每天12:00运行一次 -->  
<property name="cronExpression" value="0 0 12 * * ?" />  
</bean>

以上两种调度方式根据实际情况，任选一种即可。

第四步：配置调度工厂

<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
<property name="triggers">  
<list>  
<ref bean="cronTrigger" />  
</list>  
</property>  
</bean>

说明：该参数指定的就是之前配置的触发器的名字。

第五步：启动你的应用即可，即将工程部署至tomcat或其他容器。

到此，spring中Quartz的基本配置就介绍完了，当然了，使用之前，要导入相应的spring的包与Quartz的包，这些就不消多说了。

其实可以看出Quartz的配置看上去还是挺复杂的，没有办法，因为Quartz其实是个重量级的工具，如果我们只是想简单的执行几个简单的定时任务，有没有更简单的工具，有！

请看我第下文Spring task的介绍。

Spring-Task

上节介绍了在Spring 中使用Quartz，本文介绍Spring3.0以后自主开发的定时任务工具，spring task，可以将它比作一个轻量级的Quartz，而且使用起来很简单，除spring相关的包外不需要额外的包，而且支持注解和配置文件两种形式，下面将分别介绍这两种方式。

第一种：配置文件方式

第一步：编写作业类

即普通的pojo，如下：

import org.springframework.stereotype.Service;  
@Service  
public class TaskJob {  
      
    public void job1() {  
        System.out.println(“任务进行中。。。”);  
    }  
}

第二步：在spring配置文件头中添加命名空间及描述

<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:task="http://www.springframework.org/schema/task"   
    。。。。。。  
    xsi:schemaLocation="http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd">

第三步：spring配置文件中设置具体的任务

<task:scheduled-tasks>   
        <task:scheduled ref="taskJob" method="job1" cron="0 * * * * ?"/>   
</task:scheduled-tasks>  
  
<context:component-scan base-package=" com.gy.mytask " />

说明：ref参数指定的即任务类，method指定的即需要运行的方法，cron及cronExpression表达式，具体写法这里不介绍了，详情见上篇文章附录。

<context:component-scan base-package="com.gy.mytask" />这个配置不消多说了，spring扫描注解用的。

到这里配置就完成了，是不是很简单。

第二种：使用注解形式

也许我们不想每写一个任务类还要在xml文件中配置下，我们可以使用注解@Scheduled，我们看看源文件中该注解的定义：

@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.ANNOTATION_TYPE})  
@Retention(RetentionPolicy.RUNTIME)  
@Documented  
public @interface Scheduled  
{  
  public abstract String cron();  
  
  public abstract long fixedDelay();  
  
  public abstract long fixedRate();  
}

可以看出该注解有三个方法或者叫参数，分别表示的意思是：

cron：指定cron表达式

fixedDelay：官方文档解释：An interval-based trigger where the interval is measured from the completion time of the previous task. The time unit value is measured in milliseconds.即表示从上一个任务完成开始到下一个任务开始的间隔，单位是毫秒。

fixedRate：官方文档解释：An interval-based trigger where the interval is measured from the start time of the previous task. The time unit value is measured in milliseconds.即从上一个任务开始到下一个任务开始的间隔，单位是毫秒。

下面我来配置一下。

第一步：编写pojo

import org.springframework.scheduling.annotation.Scheduled;    
import org.springframework.stereotype.Component;  
  
@Component(“taskJob”)  
public class TaskJob {  
    @Scheduled(cron = "0 0 3 * * ?")  
    public void job1() {  
        System.out.println(“任务进行中。。。”);  
    }  
}

第二步：添加task相关的配置：

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"  
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:tx="http://www.springframework.org/schema/tx"  
    xmlns:task="http://www.springframework.org/schema/task"  
    xsi:schemaLocation="  
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd  
        http://www.springframework.org/schema/context   
http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd  
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd  
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd"  
    default-lazy-init="false">  
  
  
    <context:annotation-config />  
    <!—spring扫描注解的配置   -->  
    <context:component-scan base-package="com.gy.mytask" />  
      
<!—开启这个配置，spring才能识别@Scheduled注解   -->  
    <task:annotation-driven scheduler="qbScheduler" mode="proxy"/>  
    <task:scheduler id="qbScheduler" pool-size="10"/>

说明：理论上只需要加上<task:annotation-driven />这句配置就可以了，这些参数都不是必须的。

Ok配置完毕，当然spring task还有很多参数，我就不一一解释了，具体参考xsd文档http://www.springframework.org/schema/task/spring-task-3.0.xsd。

附录：

cronExpression的配置说明，具体使用以及参数请百度google

字段允许值允许的特殊字符

秒 0-59 , - * /

分 0-59 , - * /

小时 0-23 , - * /

日期 1-31 , - * ? / L W C

月份 1-12 或者 JAN-DEC , - * /

星期 1-7 或者 SUN-SAT , - * ? / L C #

年（可选）留空, 1970-2099 , - * /

- 区间

* 通配符

? 你不想设置那个字段

下面只例出几个式子

CRON表达式含义

"0 0 12 * * ?" 每天中午十二点触发

"0 15 10 ? * *" 每天早上10：15触发

"0 15 10 * * ?" 每天早上10：15触发

"0 15 10 * * ? *" 每天早上10：15触发

"0 15 10 * * ? 2005" 2005年的每天早上10：15触发

"0 * 14 * * ?" 每天从下午2点开始到2点59分每分钟一次触发

"0 0/5 14 * * ?" 每天从下午2点开始到2：55分结束每5分钟一次触发

"0 0/5 14,18 * * ?" 每天的下午2点至2：55和6点至6点55分两个时间段内每5分钟一次触发

"0 0-5 14 * * ?" 每天14:00至14:05每分钟一次触发

"0 10,44 14 ? 3 WED" 三月的每周三的14：10和14：44触发

"0 15 10 ? * MON-FRI" 每个周一、周二、周三、周四、周五的10：15触发

SSM框架注解的总结与详解

Sat, 13 Oct 2018 09:32:39 +0800

Spring中的注解:

注解含义：

用于创建对象的注解：

相当于：<bean id="" class="">

@Component注解：

作用：

把资源让spring来管理。相当于在xml中配置一个bean,次注解使用在实体bean的头部

@Component("accountService")

public class AccountServiceImpl implements AccountService {}

value = "accountService":相当于配置了bean标签的id属性，我们也可以不写value的值默认bean的id是当前类的类名首字母小写accountServiceImpl，单独配置value时，可以省略value。

@Controller @Service @Repository：

三个注解都是针对@Component注解的衍生注解，他们的作用及属性都是一模一样的。

相当于： <property name="" ref=""> <property name="" value="">

他们只不过是提供了更加明确的语义化。

@Controller：一般用于表现层的注解。

@Service：一般用于业务层的注解。

@Repository：一般用于持久层的注解。

细节：如果注解中有且只有一个属性要赋值时，且名称是value，value在赋值时可以不写。

用于注入数据的：

相当于： <property name="" ref=""> <property name="" value="">

@Autowired：

作用：

自动按照类型注入。当使用注解注入属性时，set方法可以省略。它只能注入其他bean类型。当有多个类型匹配时，使用要注入的对象的变量名称作为bean的id，在spring容器查找，找到了也可以注入成功。找不到就报错。

示例：

@Autowired

private AccountDao accountDao;

@Qualifier：

作用：

在自动按照类型注入的基础之上，再按照Bean的id注入。它在给字段注入时不能独立使用，必须和@Autowire一起使用，

但是给方法参数注入时，可以独立使用。

属性：

value：指定bean的id。

示例：

@Autowired

@Qualifier("accountDao2")指定将accountDao注入实体的变量名

private AccountDao accountDao;

给方法注入实参：

public JdbcTemplate craJdbcTemplate(@Qualifier("dataSource") DataSource dataSource){ }

@Resource：

作用：

直接按照Bean的id注入。它也只能注入bean类型。

属性：

name：指定bean的id。

示例：

@Resource(name="accountDao")

private AccountDao accountDao;

@Value：

作用：

注入基本数据类型和String类型数据的

属性：

value：用于指定值

示例1：

@Value("zahngsan")

private String name; name="zahngsan"

示例2：

//将配置文件jdbc.properties中的数据注解到

@Value("${jdbc.driverClass}")

private String driverClass;driverClass="com.mysql.jdbc.Driver"

用于改变作用范围的：

相当于：<bean id="" class="" scope="">

@Scope：

作用：

指定bean的作用范围。

属性：

value：指定范围的值。

取值：

singleton：默认的单例

prototype：多例

新注解说明：

@Configuration：

作用：

用于指定当前类是一个spring配置类，当创建容器时会从该类上加载注解。

获取容器时需要使用AnnotationApplicationContext(有@Configuration注解的类.class)。

示例代码：

/**

* spring的配置类，相当于applicationContext.xml文件

@Configuration

public class SpringConfiguration {

}

@ComponentScan：

作用：

用于指定spring在初始化容器时要扫描的包。作用和在spring的xml配置文件中的：

<context:component-scan base-package="cn.itcast"></context:component-scan>

属性：

Value（单独使用可省略）：用于指定要扫描的包。和标签中的basePackages属性作用一样。

示例代码：

/**

* spring的配置类，相当于bean.xml文件

@Configuration

@ComponentScan("cn.itcast")

public class SpringConfiguration {

}

@Bean：

作用：

该注解只能写在方法上，将方法的返回值作为一个bean,并且放入spring容器。id就是name的属性的值

属性：

name：给当前@Bean注解方法创建的对象指定一个名称(即bean的id）。

示例代码：

@Bean(name="dataSource")

public DataSource createDataSource() throws Exception{

ComboPooledDataSource ds = new ComboPooledDataSource();

ds.setDriverClass("com.mysql.jdbc.Driver");

ds.setJdbcUrl("jdbc:mysql://localhost:3306/heima-26");

ds.setUser("root");

ds.setPassword("root");

return ds;

}

@PropertySource：

作用：

用于加载.properties文件中的配置。例如我们配置数据源时，可以把连接数据库的信息写到properties配置文件中，就可以使用此注解指定properties配置文件的位置。

属性：

value[]：用于指定properties文件位置。如果是在类路径下，需要写上classpath:

示例代码：

@PropertySource(value = { "classpath:jdbc.properties" })

public class JdbcConfig {

@Value("${jdbc.driver}")

private String driverClass;

@Value("${jdbc.url}")

private String url;

@Value("${jdbc.username}")

private String username;

@Value("${jdbc.password}")

private String password;

@Bean(name = "dataSource")

public DataSource createDataSource() throws Exception {

ComboPooledDataSource ds = new ComboPooledDataSource();

ds.setDriverClass(driverClass);

ds.setJdbcUrl(url);

ds.setUser(username);

ds.setPassword(password);

return ds;

}

@Import：

作用：

用于导入其他配置类，在引入其他配置类时，其他类上可以不用再写@Configuration注解。当然，写上也没问题。

属性：

value[]：用于指定其他配置类的字节码。

示例代码：

@Configuration

@ComponentScan("cn.itcast")

@Import(value = { JdbcConfig.class })

public class SpringConfiguration {

}

@Configuration//写不写都行

@PropertySource(value = { "classpath:jdbc.properties" })

public class JdbcConfig {

}

Spring整合junit：

@RunWith：

作用：

替换掉junit的运行器,换成一个可以初始化spring容器的运行器。

属性：

value：单独配置时，value属性名称可以省略，配置SpringJUnit4ClassRunner.class来代替原来junit的运行器

@ContextConfiguration：

作用：

加载配置类或者xml配置文件

属性：

value[]：用来指定xml配置文件的路径

class[]: 用来指定配置类

示例：自动的加载配置文件的信息

//表示spring整合junit使用spring容器的运行器

@RunWith(SpringJUnit4ClassRunner.class)

//表示加载xml的配置的文件即可完成配置文件的加载

@ContextConfiguration(locations={"classpath:applicationContext.xml"})

配置Aop注解：

@EnableAspectJAutoProxy：

声明使用注解方式的AOP配置了：

@Configuration：

标注此类是一个配置的类相当于applicationContext.xml的加载配置的类：

@ComponentScan("com.itheima")：

标注此类相当于applicationContext.xml的加载配置的类，开启包的全局的扫描的方式：

@Configuration//标注此类是一个配置的类

@ComponentScan("com.itheima")//扫描的类

@EnableAspectJAutoProxy//声明使用注解方式的AOP配置了

public class SpringConfiguration {

}

@Aspect：

指定当前类是通知类写在类上：

@Aspect//声明这是一个切面类（通知类）里面配置的有具体的通知的方法

@Service//将此类放到容器中

public class Logger {

}

@Before：

前置通知方法：

@Before("execution(* com.itheima.serviceImpl.*.*(..))")

public void beforePrintLog() {

System.out.println("前置通知执行了");

}

@after-returning：

后置通知方法：

@AfterReturning("execution(* com.itheima.serviceImpl.*.*(..))")

public void afterReturningPrintLog() {

System.out.println("后置通知执行了");

}

@after-throwing：

异常拦截通知方法：

@AfterThrowing("execution(* com.itheima.serviceImpl.*.*(..))")

public void afterThrowingPrintLog() {

System.out.println("异常通知执行了");

}

@after：

后通知方法：

@AfterReturning("execution(* com.itheima.serviceImpl.*.*(..))")

public void afterReturningPrintLog() {

System.out.println("后置通知执行了");

}

@PointCut：

抽取切点表达式：

@Pointcut("execution(* com.itheima.serviceImpl.*.*(..))")

public void pt1(){

}

@around：

环绕通知方法：

/**

* 环绕通知

* 问题：

* 当配置完环绕通知之后，没有业务层方法执行（切入点方法执行）

* 分析：

* 通过动态代理的代码分析，我们现在的环绕通知没有明确的切入点方法调用

* 解决：

* spring框架为我们提供了一个接口，该接口可以作为环绕通知的方法参数来使用

* ProceedingJoinPoint。当环绕通知执行时，spring框架会为我们注入该接口的实现类。

* 它有一个方法proceed()，就相当于invoke，执行目标方法

* <p>

* spring的环绕通知：

* 它是spring为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。

@Around("pt1()")

public Object around(ProceedingJoinPoint pjp) {

try {

System.out.println("增强了前置通知！");

Object obj = pjp.proceed();

System.out.println("增强了后置通知！");

return obj;

} catch (Throwable e) {

System.out.println("增强了异常通知！");

throw new RuntimeException(e);

} finally {

System.out.println("增强了最终通知!");

}

基于注解的事务管理：

@Transactional：

@Transactional 注解可以被应用于接口定义和接口方法、类定义和类的 public 方法上。

注解使用在类上表明此类下的所有的方法是一个基于注解的事务

定义在接口上，只有接口的代理的实现的类可认为是基于注解的方法。因为注解不能被继承。

然而，请注意仅仅 @Transactional 注解的出现不足于开启事务行为，它仅仅是一种元数据，能够被可以识别。要开启注解的植物管理 <tx:annotation-driven/>：

SpringMvc中的注解：

@Controller：

Spring的Controller是Singleton的。这就意味着会被多个请求线程共享。因此，我们将控制器设计成无状态类：

@RequestMapping：

在类前面定义，则将url和类绑定；(如果该类里只有单个方法的话可以这样写，访问该地址直接调用该方法)：

示例代码如下：

@Controller

@RequestMapping("/getUser")

public class UserController {

......

}

定义在方法上则会为方法生成一个请求的路径：

@RequestMapping("/hello")

public String getHello() {

return "index";

}

可以携带请求的参数 Rest风格（占位符）的映射：

@RequestMapping(value=“/user/{name}/{id} ")

请求URL：http://localhost:8080/user/zhangsan/1001.do

这种方式虽然和通配符“*”类似，却比通配符更加强大，占位符除了可以起到通配的作用，最精要的地方是在于它还可以传递参数。

测试一:

@RequestMapping(value="show4/{name}/{id}")

public ModelAndView test4(){

ModelAndView mv = new ModelAndView();

mv.setViewName("hello");

mv.addObject("msg", "占位符的映射:");

return mv;

}

与其相关：

@GetMapping：相当于@RequestMapping（method = RequestMethod.GET）

@PostMapping：相当于@RequestMapping（method = RequestMethod.POST）

@PutMapping：相当于@RequestMapping（method = RequestMethod.PUT）

@DeleteMapping：相当于@RequestMapping（method = RequestMethod.DELETE）

@PathVariable：

与 Rest风格（占位符）的映射一起使用获取参数数据：

@RequestMapping(value="/show4/{name}/{id}")

public ModelAndView test4(@PathVariable("name")String name,@PathVariable("id")Long id){

ModelAndView mv = new ModelAndView();

mv.setViewName("hello");

mv.addObject("msg", "占位符的映射:"+name+"..."+id);

return mv;

}

@PathVariable(“userId”) Long id, @PathVariable(“name”)String name获取对应的参数：

@PathVariable(“key”)中的key必须和对应的占位符中的参数名一致，而方法形参的参数名可任意取：

@RequestParam：

A）常用来处理简单类型的绑定，通过Request.getParameter() 获取的String可直接转换为简单类型的情况（ String--> 简单类型的转换操作由ConversionService配置的转换器来完成）；因为使用request.getParameter()方式获取参数，所以可以处理get 方式中queryString的值，也可以处理post方式中 body data的值：

B）用来处理Content-Type: 为 application/x-www-form-urlencoded编码的内容，提交方式GET、POST：

GET模式下，这里使用了@PathVariable绑定输入参数，非常适合Restful风格。因为隐藏了参数与路径的关系，可以提升网站的安全性，静态化页面，降低恶意攻击风险。

POST模式下，使用@RequestBody绑定请求对象，Spring会帮你进行协议转换，将Json、Xml协议转换成你需要的对象。

C) 该注解有三个属性： value、required、defaultValue：

value用来指定要传入值的id名称：

required用来指示参数是否必须绑定：

defaultValue用来指定在前端没有传值的情况下限定默认的值：

@RequestMapping(value="show19")

public String test19(Model model,@RequestParam(value="name")String name){

model.addAttribute("msg", "使用@RequestParam接收到的参数为："+name);

return "hello";

}

@ResponseStatus(value=HttpStatus.OK)：如果不响应页面，就需要响应状态：

@RequestMapping(value = "show23")

@ResponseStatus(value=HttpStatus.OK)//不响应页面，就需要响应个状态码

public void test23(@RequestParam("name")String name,

@RequestParam("age")Integer age,

@RequestParam("isMarry")Boolean isMarry, //可以将on或者1转换为true,0转换为false.

@RequestParam("income")Float income,

@RequestParam("interests")String[] interests) {

StringBuffer sb = new StringBuffer();

sb.append("name:"+name+"\n");

sb.append("age:"+age+"\n");

sb.append("isMarry:"+isMarry+"\n");

sb.append("income:"+income+"\n");

sb.append("interests:[");

for (String inter : interests) {

sb.append(inter+" ");

}

sb.append("]");

System.out.println(sb.toString());

}

@CookieValue使用方法同@RequestParam：获取cookie的值：

@RequestMapping(value = "show22")

public String test22(Model model, @CookieValue("JSESSIONID")String jsessionid) {

model.addAttribute("msg", "jsessionid：" + jsessionid);

return "hello";

}

@ResponseBody：

当一个处理请求的方法标记为@ResponseBody时，表示该方法需要输出其他视图（json、xml），springmvc会通过默认的json转化器转化输出,但是需要引入相关的jar包：

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

<artifactId>jackson-databind</artifactId>

</dependency>

/**

* 将list集合响应成json数据

* @return

@RequestMapping(value="show28")

@ResponseBody//将数据响应成json格式的数据

public List<User> test28() {

List<User> list = new ArrayList<User>();

for(int i = 0;i< 20;i++) {

User user = new User();

user.setId(i+1L);

user.setUsername("zhangsan"+i);

user.setName("张三"+i);

user.setAge(18);

list.add(user);

}

return list;

}

@RequestBody：接收一个json并且转换成一个对象

/**

* 将提交的json格式的数据封装到user对象中

* @RequestBody()：自动将json数据序列化成一个user对象

* @param model

* @param user

* @return

@RequestMapping(value="show29")

public String test29(Model model,@RequestBody()User user) {

model.addAttribute("msg", user);

return "hello";

}

@RestController：

有时如果在一个Contoller中所有的方法都是用来响应json格式数据的，那么如果有多个方法，就需要在多个方法上使用@ResponseBody，这样太麻烦，springmvc提供了一个@RestController，将该注解使用在Controller类上，那么该controller中的所有方法都默认是响应json格式的数据了：

---------------------

作者：低调的繁华6

来源：CSDN

原文：https://blog.csdn.net/weixin_42696130/article/details/81051126?utm_source=copy

Dhboy工作室

JFinalConfig-configConstant（JFinal常量配置）

老骥教大家如何给阿里云香港轻量级服务器提速

《DHBOY企业站管理》快速上手文档

【限时特惠】公司个性化网站建设限时优惠

【限时免费】钢材现货查询系统限免费使用！

宝塔mysql总是自动停止解决总汇

系统安全性之十大措施

一、MD5 加密用户密码

二、COOKIES加密

三、SQL注入防护

四、木马和病毒防护

五、权限控制系统

六、IP记录

七、隐藏的程序入口

八、有限的写文件

九、作了MD5校验的订单数据

十、编译执行的代码

单用户登录

Spring定时任务的几种实现

一．分类

从实现的技术上来分类，目前主要有三种技术（或者说有三种产品）：

从作业类的继承方式来讲，可以分为两类：

从任务调度的触发时机来分，这里主要是针对作业使用的触发器，主要有以下两种：

二．用法说明

Quartz

第一种，作业类继承自特定的基类：org.springframework.scheduling.quartz.QuartzJobBean。

第一步：定义作业类

第二步：spring配置文件中配置作业类JobDetailBean

第三步：配置作业调度的触发方式（触发器）

第四步：配置调度工厂

第五步：启动你的应用即可，即将工程部署至tomcat或其他容器。

第二种，作业类不继承特定基类。

第一步：编写任务类

第二步：配置作业类

第三步：配置作业调度的触发方式（触发器）

第四步：配置调度工厂

第五步：启动你的应用即可，即将工程部署至tomcat或其他容器。

Spring-Task

第一种：配置文件方式

第一步：编写作业类

第二步：在spring配置文件头中添加命名空间及描述

第三步：spring配置文件中设置具体的任务

第二种：使用注解形式

第一步：编写pojo

第二步：添加task相关的配置：

SSM框架注解的总结与详解