SSM+Shiro+layui项目的学习

最新推荐文章于 2025-07-19 15:38:08 发布

原创最新推荐文章于 2025-07-19 15:38:08 发布 · 1.5k 阅读

2 ·

CC 4.0 BY-SA版权

JavaWeb_Project 专栏收录该内容

5 篇文章

订阅专栏

本文详述了SSM（Spring、SpringMVC、MyBatis）结合Shiro实现权限管理的项目学习过程，包括SSM项目框架搭建、Shiro的配置与使用，如认证、授权，以及Shiro Realm与数据库交互。此外，还介绍了项目的自我学习，如IDEA导入Maven项目、Web.xml配置、登录验证流程、layui前端框架的使用以及权限菜单的显示等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

SSM项目框架的学习

转载：https://blog.youkuaiyun.com/chijiandi/article/details/80169758 作者：从放弃到开始

目的：主要去看代码，理解代码

快速了解一个项目：https://www.cnblogs.com/orac/p/7852776.html 作者：改变

一、web.xml

shiro学习

参考文档：https://www.cnblogs.com/learnhow/p/5694876.html 作者：思踌之路

权限管理系统包括：认证和授权两部分

1. shiro简单实例

archetypeCatalog=internal maven项目的骨架不要到远程下载而是本地获取 // 貌似maven不在支持这个了

1) 环境搭建

2) shiro.ini

[users]
zhangsan=123456
sili=123456

了解shiro.ini文件 https://blog.youkuaiyun.com/u011781521/article/details/74892074 作者：lfendo

3) 简单认证

public class ShiroTest {

    public static void main(String[] args) {

        // 1. 获取实例，加载shiro-first.ini
        IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro-first.ini");
        // 2. 获取安全管理器securityManager
        org.apache.shiro.mgt.SecurityManager securityManager = factory.getInstance();
        // 3. 将创建好的安全管理器注入到SecurityUtils中去
        SecurityUtils.setSecurityManager(securityManager);
        // 4. 获取主体(用户)
        Subject subject = SecurityUtils.getSubject();
        // 5. 模拟用户输入的信息
        String userName = "zhangsan1";
        String password = "123456";
        // 6. 创建Token,通过UsernamePasswordToken包装客户端发送信息(账号，密码等信息)
        UsernamePasswordToken token = new UsernamePasswordToken(userName,password);
        try {
            // 7. 进行登录和认证
            subject.login(token);
        } catch (AuthenticationException e) {
            e.printStackTrace();
        }
        // 8. 是否已认证通过
        boolean flag = subject.isAuthenticated();
        System.out.println(flag);
    }
}

2. shiro查询数据库

使用Realm与数据库进行交互自定义realm

1) 环境配置

2) shiro-realm.ini

[main]
customRealm=com.yan.shiro.realm.CustomRealm
securityManager.realms=$customRealm

3) CustomRealm

package com.yan.shiro.realm;

import com.yan.shiro.domain.User;
import com.yan.shiro.service.IUserService;
import com.yan.shiro.service.impl.UserServiceImpl;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;

import java.util.Set;

public class CustomRealm extends AuthorizingRealm {

    private IUserService userService = new UserServiceImpl();

    @Override
    public String getName() {
        return "CustomRealm";
    }

    /**
     *  进行授权操作
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("开始进行授权");


        String userName = (String) principalCollection.getPrimaryPrincipal();
        // 根据用户查询用户角色
        Set<String> roleNameList = userService.findAllRoleNameByUserName(userName);
        // 将用户角色信息交给shiro进行管理
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo(roleNameList);
        // 将用户操作[user:add  user:delete   role:add]
        Set<String> permissionNames = userService.findAllPermissionNameByUserName(userName);
        simpleAuthorizationInfo.addStringPermissions(permissionNames);

        return simpleAuthorizationInfo;
    }

    /**
     * 进行认证操作
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        System.out.println("开始进行认证");
        // 通过token获取用户信息
        String userName = (String) token.getPrincipal();
        System.out.println(userName);
        // 这个无法获取用户密码
        // String password = (String) token.getCredentials();
        // System.out.println("userName:" + userName + ",password:" + password);

        // 根据用户的账号获取用户信息
        User user = userService.findByName(userName);
        if (user == null){
            return null;
        }
        // 获取用户的密码
        String p = user.getPassword();
        SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(userName,p,this.getName());

        return simpleAuthenticationInfo;
    }
}

3) 测试

package com.yan.shiro.service.impl;

import com.yan.shiro.domain.User;
import com.yan.shiro.service.IUserService;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class UserServiceImpl implements IUserService {

    private static List<User> userList = new ArrayList<>();

    static {
        User user1 = new User();
        user1.setId(1);
        user1.setName("zhangsan");
        user1.setPassword("123456");
        userList.add(user1);

        User user2 = new User();
        user2.setId(2);
        user2.setName("lisi");
        user2.setPassword("123456");
        userList.add(user2);

        User user3 = new User();
        user3.setId(3);
        user3.setName("wangwu");
        user3.setPassword("123456");
        userList.add(user3);
    }

    @Override
    public User findByName(String name) {

        for (User user:userList) {
            if (user.getName().equals(name)){
                return user;
            }
        }
        return null;
    }

    @Override
    public Set<String> findAllRoleNameByUserName(String userNmae) {
        Set<String> roleNameList = new HashSet<>();
        roleNameList.add("系统管理员");
        roleNameList.add("VIP");

        return roleNameList;
    }

    @Override
    public Set<String> findAllPermissionNameByUserName(String userNmae) {
        Set<String> permissionNames = new HashSet<>();
        permissionNames.add("user:add");
        permissionNames.add("user:delete");
        permissionNames.add("role:delete");
        permissionNames.add("module:delete");

        return permissionNames;
    }
}

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.subject.Subject;


public class ShiroTest {

    public static void main(String[] args) {

        // 进行认证
        Subject subject = authenticate();

        // 进行授权
        authorize(subject);

    }

    public static Subject authenticate(){
        // 1. 获取实例，加载shiro-first.ini
        IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro-realm.ini");
        // 2. 获取安全管理器securityManager
        org.apache.shiro.mgt.SecurityManager securityManager = factory.getInstance();
        // 3. 将创建好的安全管理器注入到SecurityUtils中去
        SecurityUtils.setSecurityManager(securityManager);
        // 4. 获取主体(用户)
        Subject subject = SecurityUtils.getSubject();
        // 5. 模拟用户输入的信息
        String userName = "zhangsan";
        String password = "123456";
        // 6. 创建Token,通过UsernamePasswordToken包装客户端发送信息(账号，密码等信息)
        UsernamePasswordToken token = new UsernamePasswordToken(userName,password);
        try {
            // 7. 进行登录和认证
            subject.login(token);
        } catch (AuthenticationException e) {
            e.printStackTrace();
        }
        // 8. 是否已认证通过
        boolean flag = subject.isAuthenticated();
        System.out.println(flag);

        return subject;
    }

    public static void authorize(Subject subject){
        System.out.println(subject.hasRole("系统管理员"));
        System.out.println(subject.isPermitted("user:add"));
    }
}

3. shiro整合spring

shiro

spirng

mybatis

mysql驱动

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

项目自我学习

1. 配置项目

IDEA导入Maven工程：https://www.cnblogs.com/longronglang/p/8179616.html 作者：Refain

2. web.xml

<welcome-file-list>
    <welcome-file>/login.jsp</welcome-file>
</welcome-file-list>

启动后，跳转到login.jsp页面

3. login

Ajax：

/sys/login 登录操作
/sys/index 登录成功之后，(~~跳转到index.jsp页面)，~~然而其实并不是直接跳转到index.jsp页面，需要布局整个index.jsp页面，即要查询当前用户的权限信息

AccountController管理登录事物：

(1) /login

传递进来的username、password、vcode与数据库和后端代码进行对比，首先判断username、password、vcode是否为空，如果为空，抛出自定义异常RRException
再先验证验证码是否正确，验证码(是在跳转login.jsp就产生了，存放在session中，相当于刷新，刷新使得时间不同，则refreshCode产生验证码，/vcode真正产生验证码
shiro来对用户进行验证，验证成功，返回ResultUtil.ok()---即result----带有code=0，前端login.js中code==0，跳转到/index

(2) /index

获取当前用户的信息TbAdmin，并将信息存入到admin中
再跳转到index.jsp

4. index.jsp模块用的时layUI页面框架

(1) /sys/getMenus

获取当前用户的权限。关键的是adminServiceImpl.selMenus(admin)，这是一步步查询的过

获取获取当前用户的id 对应的table：tb_roles
通过roleId获取权限对应的表：tb_roles_menus

TbRolesMenusExample example = new TbRolesMenusExample();

// 将数据查询封装为一个对象，Criteria Qeury可以看作传统SQL的对象化表示

com.irs.pojo.TbRolesMenusExample.Criteria criteria = example.createCriteria();
criteria.andRoleIdEqualTo(roleId);



// Example

Criteria criteria = session.createCriteria(User.class);
criteria.add(Expression.eq("name","Erica"));
criteria.add(Expression.eq("sex",new Integer(1)));

// 实例为：
select * from t_user where name=’Erica’ and sex=<chmetcnv tcsc="0" w:st="on" unitname="" sourcevalue="1" numbertype="1" negative="False" hasspace="False"></chmetcnv>1”

联表查询：tb_menu和tb_roles_menus

// adminMenusMapper.getMenus(roleId)   联表查询tb_menu和tb_roles_menus   
List<TbMenus> menus = adminMenusMapper.getMenus(roleId);
for (int i = 0; i < menus.size(); i++) {
    // 如果parentId==0,
    if (menus.get(i).getParentId() == 0) {
        Menu menu = new Menu();
        menu.setTitle(menus.get(i).getTitle());
        menu.setIcon(menus.get(i).getIcon());
        menu.setHref(menus.get(i).getHref());
        menu.setSpread(menus.get(i).getSpread());
        List<Menu> menus2 = new ArrayList<>();
        for (int j = 0; j < menus.size(); j++) {
            if (menus.get(j).getParentId() == menus.get(i).getMenuId()) {
                Menu menu2 = new Menu();
                menu2.setTitle(menus.get(j).getTitle());
                menu2.setIcon(menus.get(j).getIcon());
                menu2.setHref(menus.get(j).getHref());
                menu2.setSpread(menus.get(j).getSpread());
                menus2.add(menu2);
            }
        }
        menu.setChildren(menus2);
        results.add(menu);
    }
}

(2) 权限菜单显示

index.js https://www.layui.com/doc/base/modules.html layui配置--设定模块所在的目录，然后就可以在别的JS文件中使用了
navBar 左侧导航--用户菜单其中strData解析的就是/sys/getMenus传进来的值 (如何传进来未搞懂。。。)

(3) main.jsp

加载主页面标题：后台首页
加载主页面操作设置：刷新当前、关闭其他、关闭全部
加载主页面：/sys/main ---> return page/main.jsp
main.js

主页面操作设置(index.jsp和index.js)：

刷新当前---------不能连续刷新
关闭其他---------首先得有新窗口，判断窗口数量是否大于2(其中后台首页窗口不能关闭)并且当前窗口不为"后台首页"

// 添加新窗口
$("body").on("click",".layui-nav .layui-nav-item a",function(){
    //如果不存在子级
    if($(this).siblings().length == 0){
        addTab($(this));
        $('body').removeClass('site-mobile');  //移动端点击菜单关闭菜单层
    }
    $(this).parent("li").siblings().removeClass("layui-nav-itemed");
})


//打开新窗口
function addTab(_this){
    tab.tabAdd(_this);
}

关闭全部---------

MainController：

main/getUserTotal：获取所有的用户
main/getUsersToday：获取今天创建的用户
main/getUsersYeresday：获取昨天创建的用户
main/getUsersMonth：获取本周创建的用户
main/getUsersMonth：获取本月创建的用户
/main/dataAccessGender：获取所有用户的性别

main.js：

json/systemParameter.json // 获取系统基本参数 --------------(systemParameter.json)

4. 用户管理模块

用户管理模块有两个内容，一个为管理用户，一个添加用户

(1) 管理用户

显示所有用户信息，可对用户进行编辑(修改用户信息)和删除操作
分页
各种查询查询语句拼接

点击管理用户，出现管理用户窗口 user/userList--数据的操作

UserManagementController：

user/userList：

@RequestMapping("userList")                 // 映射地址
@RequiresPermissions("user:user:list")      // shiro权限管理
public String userList(){
	return "page/user/userList";
}

// 只是返回到userList.jsp页面，真正加载用户数据的是在userList.jsp页面完成的

//加载页面数据
table.render({
    id : 'userList',
    elem : '#userList',
    url : ctx + '/user/getUserList', //数据接口
    limit : 10,//每页默认数
    limits : [ 10, 20, 30, 40 ],
    cols : [ [ //表头
        {
            type : 'checkbox'
        },
        {
            field : 'uid',
            title : 'ID',
            width : 60
        },
        {
            field : 'eMail',
            title : '邮箱'
        },
        {
            field : 'nickname',
            title : '昵称'
        },
        {
            field : 'sex',
            title : '性别',
            templet : '#sexTpl'
        },
        {
            field : 'birthday',
            title : '出生日期',
            templet : '<div>{{ formatTime(d.birthday,"yyyy-MM-dd")}}</div>'
        },
        {
            field : 'address',
            title : '地址'
        },
        {
            field : 'phone',
            title : '手机',
            width : 120
        },
        {
            field : 'status',
            title : '状态',
            templet : '#statusTpl'
        },
        {
            field : 'createTime',
            title : '注册日期',
            templet : '<div>{{ formatTime(d.createTime,"yyyy-MM-dd hh:mm:ss")}}</div>'
        }, 
        {
            title : '操作',
            toolbar : '#barEdit'
        } ] ],
    page : true,where: {timestamp: (new Date()).valueOf()}
    //开启分页
});



// 获取数据
@RequestMapping("getUserList")
@RequiresPermissions("user:user:list")
@ResponseBody
public ResultUtil getUserList(Integer page,Integer limit,UserSearch search){
    return userServiceImpl.selUsers(page,limit,search);
}

编辑及删除

<shiro:hasPermission name="user:user:update">
    <a class="layui-btn layui-btn-xs" lay-event="edit">编辑</a>
</shiro:hasPermission>
<shiro:hasPermission name="user:user:delete">
    <a class="layui-btn layui-btn-danger layui-btn-xs" lay-event="del">删除</a>
</shiro:hasPermission>


// 编辑简单，删除是根据id来进行删除的
//监听工具条
table.on('tool(userList)', function(obj) {
    var data = obj.data;
    if (obj.event === 'del') {
        layer.confirm('真的删除行么', function(index) {
            $.ajax({
                url : ctx + '/user/delUserByUid/' + data.uid,
                type : "get",
                success : function(d) {
                    if (d.code == 0) {
                        obj.del();
                    } else {
                        layer.msg("权限不足！", {
                            icon : 5
                        });
                    }
                }
             });
             layer.close(index);
        });
   } else if (obj.event === 'edit') {
        layer.open({
        type : 2,
        title : "编辑用户",
        area : [ '400px', '500px' ],
        content : ctx + "/user/editUser/" + data.uid //这里content是一个普通的String
   })
}

添加用户有两种：

// 第一种是在管理用户界面
//添加用户
$(".userAdd_btn").click(function() {
    var index = layui.layer.open({
    title : "添加用户",
    type : 2,
    content : ctx + "/user/addUser",
    success : function(layero, index) {

    }
    });
    //改变窗口大小时，重置弹窗的高度，防止超出可视区域（如F12调出debug的操作）
    $(window).resize(function() {
    layui.layer.full(index);
    })
    layui.layer.full(index);
});

@RequestMapping("addUser")
@RequiresPermissions("user:user:save")
public String userAdd(){
    return "page/user/addUser";
}


// 第二种直接是添加用户菜单
@SysLog(value="添加用户")
@RequestMapping("insUser")
@RequiresPermissions("user:user:save")
@ResponseBody
public ResultUtil insUser(TbUsers user){
    //防止浏览器提交
    TbUsers u1 = userServiceImpl.selUserByEmail(user.geteMail(),null);
    TbUsers u2 = userServiceImpl.selUserByNickname(user.getNickname(),null);
    if(u1!=null){
        return new ResultUtil(500,"邮箱已存在，请重新填写！");
    }
    if(u2!=null){
        return new ResultUtil(501,"昵称已存在，请重新填写！");
    }
    try {
        userServiceImpl.insUserService(user);
        return ResultUtil.ok();
    } catch (Exception e) {
        //e.printStackTrace();
        return new ResultUtil(502,"邮件发送错误，请检查邮箱！");
    }
}


// 其实只用了第一种，第二种貌似没用。。。

5. 管理员管理模块

管理员列表 sys/adminList--->sys/getAdminList
菜单列表 sys/menuList---->sys/menuData
角色管理 sys/roleList

(1) 管理员列表：

包括显示管理员列表，对于的table--tb_roles 有编辑和删除操作
添加管理员
批量删除

6. 日志管理(系统日志) log/logList

如何自动保存日志，并将日志记录在数据库中

使用了切面编程，拦截Controller层记录用户操作

package com.irs.annotation;

import org.apache.shiro.SecurityUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.irs.pojo.TbAdmin;
import com.irs.pojo.TbLog;
import com.irs.service.LogService;
import com.irs.util.JsonUtils;
import com.irs.util.MyUtil;
import com.irs.util.WebUtils;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.lang.reflect.Method;

/**
 * 切点类   
 * @author Mr Du
 */
@Aspect
@Component
public  class SystemLogAspect {
    //注入Service用于把日志保存数据库    
    @Resource
    private LogService logServiceImp;
    //本地异常日志记录对象    
    private  static  final Logger logger = LoggerFactory.getLogger(SystemLogAspect. class);

    //Controller层切点    
    @Pointcut("@annotation(com.irs.annotation.SysLog)")
    public  void controllerAspect() {
    }

    /**
     * 前置通知 用于拦截Controller层记录用户的操作  
     *
     * @param joinPoint 切点  
     */
    @Before("controllerAspect()")
    public  void doBefore(JoinPoint joinPoint) {

        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession session = request.getSession();
        //读取session中的用户    
        TbAdmin user = (TbAdmin)SecurityUtils.getSubject().getPrincipal();
        //请求的IP    
        //String ip = request.getRemoteAddr();

        String requestURI=request.getRequestURI();

        String ip=WebUtils.getRemoteAddr(request);
        String method = joinPoint.getSignature().getDeclaringTypeName() +
                "." + joinPoint.getSignature().getName();
        String params = "";
        if (joinPoint.getArgs() !=  null && joinPoint.getArgs().length > 0) {
            for ( int i = 0; i < joinPoint.getArgs().length; i++) {
                params+=JsonUtils.objectToJson(joinPoint.getArgs()[i])+";";
            }
        }
        try {
            //*========控制台输出=========*//    
            //System.out.println("=====前置通知开始=====");    
            String operation=getControllerMethodDescription(joinPoint);
            String username=user.getUsername();
            //System.out.println("请求参数:" + params);    
            TbLog log=new TbLog();
            log.setCreateTime(MyUtil.getNowDateStr2());
            log.setIp(ip);
            log.setOperation(operation);
            log.setParams(params);
            log.setUsername(username);
            log.setMethod(requestURI);
            //*========保存数据库日志=========*// 
            //System.out.println(log);
            logServiceImp.insLog(log);
            //保存数据库    
        }  catch (Exception e) {
            //记录本地异常日志    
            logger.error("==前置通知异常==");
            logger.error("异常信息:{}", e.getMessage());
        }
    }

    /**
     * 获取注解中对方法的描述信息 用于Controller层注解  
     *
     * @param joinPoint 切点  
     * @return 方法描述
     * @throws Exception
     */
    public  static String getControllerMethodDescription(JoinPoint joinPoint)  throws Exception {
        String targetName = joinPoint.getTarget().getClass().getName();
        String methodName = joinPoint.getSignature().getName();
        Object[] arguments = joinPoint.getArgs();
        Class targetClass = Class.forName(targetName);
        Method[] methods = targetClass.getMethods();
        String description = "";
        for (Method method : methods) {
            if (method.getName().equals(methodName)) {
                Class[] clazzs = method.getParameterTypes();
                if (clazzs.length == arguments.length) {
                    description = method.getAnnotation(SysLog. class).value();
                    break;
                }
            }
        }
        return description;
    }
}

7. SQL监控 sys/druid

@RequestMapping("/druid")
@RequiresPermissions("sys:druid:list")
public String druid(){
    return "redirect:/druid/index.html";
}

druid/index.html属于driud内置网页

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

学习druid：

数据连接池：

C3P0
DBCP
Druid

Druid优点：

数据库连接池
自带监控页面，实时监控应用的连接池情况

配置：

// 1. 数据源
// db.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/irs?characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

// 2. 配置    在applicationContext-dao.xml  

<!-- 加载配置文件 -->
<context:property-placeholder location="classpath:resource/*.properties"/>
<!-- 数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
    <property name="url" value="${jdbc.url}" />
    <property name="username" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
    <property name="driverClassName" value="${jdbc.driver}" />
    <property name="maxActive" value="10" />
    <property name="minIdle" value="5" />

    <!-- 开启Druid的监控统计功能 -->
    <property name="filters" value="stat,logback" />
</bean> 


// 3. web.xml打开监控服务

<filter>
    <filter-name>DruidWebStatFilter</filter-name>
    <filter-class>com.alibaba.druid.support.http.WebStatFilter</filter-class>
    <init-param>
        <param-name>exclusions</param-name>
        <param-value>/static/*,*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*</param-value>
    </init-param>
    <init-param>
        <param-name>profileEnable</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>DruidWebStatFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

8. 任务调度器：quartz

定时任务

Quartz是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行,可以方便的分布式部署、便捷的监控和管理任务，适合任务很多的情况

// 配置文件   spring-scheduled.xml


<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:task="http://www.springframework.org/schema/task" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context-3.0.xsd 
    http://www.springframework.org/schema/task 
    http://www.springframework.org/schema/task/spring-task-3.0.xsd"> 
	
<task:annotation-driven />
    <!-- 指定扫描位置 -->
    <context:annotation-config />
    <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />
    <context:component-scan base-package="com.irs.quartz" />
</beans>

package com.irs.quartz;

import java.util.Date;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import com.irs.pojo.TbLog;
import com.irs.service.LogService;
import com.irs.util.DateUtil;
import com.irs.util.GlobalUtil;

/**
 * 清除系统日志任务
 * @author Mr Du
 *
 */

@Component
public class MethodLogQuartz {
    private static Logger LOGGER = Logger.getLogger(MethodLogQuartz.class);
    private static final String LOGDAYS = "log.days";

    @Autowired
    private LogService logServiceImpl;
    /** 
     * cron表达式：* * * * * *（共6位，使用空格隔开，具体如下） 
     * cron表达式：*(秒0-59) *(分 钟0-59) *(小时0-23) *(日期1-31) *(月份1-12或是JAN-DEC) *(星期1-7或是SUN-SAT) 
     */ 
    @Scheduled(cron="0 0 0 * * ?")
    public void clearLog() {
        int logDays = Integer.valueOf(GlobalUtil.getValue(LOGDAYS));
        Date date = DateUtil.getDate(DateUtil.getDate(), -logDays);
        int count =logServiceImpl.delLogsByDate(date);
        String date1=DateUtil.getStringDate(date, DateUtil.DateFormat1);
		LOGGER.info("日志定时删除任务，删除日志数量:" + count + ", createDate < "
                + date1);
        TbLog log=new TbLog();
        log.setIp("");
        log.setOperation("定时删除日志："+count+"条");
        log.setCreateTime(date1);
        log.setUsername("系统自动任务");
        log.setMethod("");
        log.setParams("");
        logServiceImpl.insLog(log);
    }
}