springmvc02

无区新手

已于 2024-08-28 11:08:56 修改

阅读量284

点赞数

分类专栏： SpringMVC 文章标签： java 开发语言

于 2020-07-19 15:56:54 首次发布

本文链接：https://blog.csdn.net/qq_40660787/article/details/107446050

版权

SpringMVC 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

在springmvc中，实现文件上传

步骤:
1、创建web应用

2、导入jar

        spring 4.2

            core,beans,context,expression,aop,aspects,web,webmvc

        spring 3.0.2
            logging, aop联盟,织入

        jsp:
            jstl,standard
        
        增加: commons-io.jar,  commons-fileupload.jar

3、jsp页面的要求:

上传的表单，提交方式必须是post方式
要指定表单的类型，允许携带文件
<form action="" method="post" enctype="multipart/form-data">
上传控件，使用<input type="file" name="xxx">

4、编写applicationContext.xml

        <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="defaultEncoding" value="utf-8"/><!--默认编码-->
        <property name="maxInMemorySize" value="2097152"/><!--文件上传时，每次向内存写入数据最大值-->
        <property name="maxUploadSize" value="20971520"/><!--上传的文件大小的最大值-->
        <property name="uploadTempDir" value="temp"/>
        </bean>

5、控制器类

package org.java.web;

import org.springframework.stereotype.Controller;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.commons.CommonsMultipartFile;

import java.io.File;

@Controller
public class FileController {


    @RequestMapping(value = "/up",method = RequestMethod.POST)
    public String upload(String name,@RequestParam("myfile") CommonsMultipartFile myfile) throws  Exception{


        System.out.println("姓名是："+name);

        //获得要上传的文件名称
        String fname = myfile.getOriginalFilename();

        //判断是否有文件
        if(!StringUtils.isEmpty(fname)){
            //获得文件要保存的路径
            File newFile = new File("d91",fname);//新文件（空文件，没有数据）

            //判断，当前文件所有在目录是否存在
            if(!newFile.getParentFile().exists()){
                //目录不存在
                newFile.getParentFile().mkdirs();
            }

            //将上传文件中的数据，写入到新文件中
            myfile.getFileItem().write(newFile);
        }



        return "/ok";
    }

}

邮件发送

在处理邮件发送时，会涉及到两种类型的协议：

smtp:SMTP是一种提供可靠且有效的电子邮件传输的协议
它用于描述，如何去发送邮件
pop3:POP3，全名为“Post Office Protocol - Version 3”，即“邮局协议版本3”
它用于描述，如何从邮件服务器中获取邮件

发送邮件之前，要要设定你自己的邮件服务器，要开通smpt,pop3协议

我生成的密码：zsjcnmhztefecaii

在程序中，编写代码发送邮件时，主要分为两种类型的邮件:

简单邮件------------------------------这种邮件，只能发送消息，不能带附件
允许携带附件的邮件-------------------可以发送附件

简单邮件

步骤：

1、创建一个springmvc的应用

2、导入springmvc涉及到的相关的jar

然后再加上: fileupload,io,mail,spring-context-support

3、编写mail.properties文件，配置邮件发送的相关信息

        #邮件服务器的地址
        mail.host=smtp.qq.com
        #发件人
        mail.user=xxxxxx@qq.com
        #密码
        mail.pwd=zsjcnmhztefecaii
        #发送邮件的协议
        mail.protocol=smtp
        #是否认证用户信息
        mail.auth=true
        #延迟时间
        mail.timeout=3000
        #编码
        mail.encoding=utf-8

4、编写spring的主配置文件 applicationContext.xml

<context:property-placeholder location="classpath:mail.properties"/>


    <bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
            <property name="host" value="${mail.host}"/>
            <property name="username" value="${mail.user}"/>
            <property name="password" value="${mail.pwd}"/>
            <property name="defaultEncoding" value="${mail.encoding}"/>
            <property name="protocol" value="${mail.protocol}"/>
            <property name="javaMailProperties">
                <props>
                    <!--发送时，要否要验证用户-->
                    <prop key="auth">${mail.auth}</prop>
                    <!--超时时间，超过这个时间没有连接上服务，就不再连接-->
                    <prop key="timeout">${mail.timeout}</prop>
                </props>
            </property>
        </bean>

5、编写页面，准备发送邮件

         <form action="simple.do" method="post">
             收件人：<input type="text" name="to" size="100px"/><Br>
             标  题：<input type="text" name="title" size="100px"/><Br>
             内  容：<TEXTAREA cols="40" rows="5" name="msg"></TEXTAREA><Br>
            <input type="submit" value="发送"/>
          </form>

6、在控制器类中，编写代码发送邮件

             @Autowired
            private JavaMailSenderImpl sender;

           //发件人
            @Value("${mail.user}")
            private String from;    

            @RequestMapping(value = "/simple",method = RequestMethod.POST)
            public String simpleMail(String to,String title,String msg){

            //创建一个简单邮件
            SimpleMailMessage  mail = new SimpleMailMessage();

            //指定收件人
            mail.setTo(to);
            //指定邮件主题
            mail.setSubject(title);
            //设置邮件正文
            mail.setText(msg);
            //设置发件人
            mail.setFrom(from);

            //发送邮件
            sender.send(mail);

            return "/ok";

            }

带附件的邮件发送:

在applicationContext.xml文件，增加文件上传的配置

        <!--配置文件上传-->
        <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
            <property name="defaultEncoding" value="utf-8"/>
            <property name="maxUploadSize" value="20971520"/>
            <property name="maxInMemorySize" value="2097152"/>
        </bean>

控制器类

package org.java.web;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSenderImpl;
import org.springframework.mail.javamail.MimeMailMessage;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.commons.CommonsMultipartFile;

import javax.mail.internet.MimeMessage;

@Controller
public class MailController {

    //邮件发送对象
    @Autowired
    private JavaMailSenderImpl sender;

    //发件人
    @Value("${mail.user}")
    private String from;

    /**
     * 简单邮件，不带附件
     * 在发送一封邮件时，至少要包含四个属性
     * 1、收件人
     * 2、发件人
     * 3、主题 （标题）
     * 4、正文（内容）
     * @param to
     * @param title
     * @param msg
     * @return
     */
    @RequestMapping(value = "/simple",method = RequestMethod.POST)
    public String simpleMail(String to,String title,String msg){

        //创建一个简单邮件
        SimpleMailMessage  mail = new SimpleMailMessage();

        //指定收件人
        mail.setTo(to);
        //指定邮件主题
        mail.setSubject(title);
        //设置邮件正文
        mail.setText(msg);
        //设置发件人
        mail.setFrom(from);

        //发送邮件
        sender.send(mail);

        return "/ok";

    }


    /**
     * 带附件的邮件
     * @param to
     * @param title
     * @param msg
     * @param myfile
     * @return
     */
    @RequestMapping(value = "/complex",method = RequestMethod.POST)
    public String complex(String to, String title, String msg,@RequestParam CommonsMultipartFile myfile) throws  Exception{

        //创建一个可以携带附件的邮件
        MimeMessage message = sender.createMimeMessage();

        MimeMessageHelper helper =new MimeMessageHelper(message,true);//true:表示允许携带附件

        //如果有多个收件人,可以按指定符号分割
        String[] toUsers = to.split(",");

        helper.setTo(toUsers);//收件人
        helper.setFrom(from);//发件人
        helper.setSubject(title);//主题
        helper.setText("<A style='color:blue' href='http://www.163.com'>"+msg+"</a>",true);//内容

        //要得到文件的名称
        String fname = myfile.getOriginalFilename();

        //给邮件加载附件
        helper.addAttachment(fname,myfile);

        sender.send(message);

        return "/ok";


    }










}

springmvc的拦截器 Interceptor

拦截器：主要是请求附加功能

一般在访问请求时，对请求进行拦截，拦截后可以附加功能，功能附加完成以后，再去调用请求

拦截器主要是针对于控制器类进行拦截

任务1：通过拦截器实现一个权限控制

1、不论用户登录不登录，都可以看见主界面

2、如果用户要操作页面上的功能，将判断，用户是否登录，如果已登录直接运行对应的功能，如果没有登录，
则进入登录界面

编写拦截器的步骤：

1、编写拦截类LoginInterceptor继承于 HandlerInterceptorAdpater (拦截处理适配器)

拦截器属于辅助工具，一般放在util包中

package org.java.util;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class LoginInterceptor extends HandlerInterceptorAdapter {

    //前置拦截的方法---------------------------------------该方法会在进入控制器之前运行

    /**
     *
     * @param request 请求
     * @param response 响应
     * @param handler 控制器类（进入哪一个控制器类时，被拦截的。handler：表示拦截器的控制器类）
     * @return  返回true:当前代码，会继续进入控制器类，返回false:程序不再进入控制器
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        //获得session
        HttpSession ses = request.getSession();

        //从sesssion获得用户信息
        Object user = ses.getAttribute("user");

        //判断user是否为空
        if(user==null){
            //重定向到登录界面
            response.sendRedirect("/login.jsp");

            return false;//不进入控制器类
        }

        return super.preHandle(request, response, handler);
    }

//    //后置拦截的方法---------------------------------------该方法会在控制器的代码运行完成以后执行
//    @Override
//    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
//
//        System.out.println("3、进入postHandle");
//        super.postHandle(request, response, handler, modelAndView);
//    }
//
//
//    //该方法将会本次请求即将结束之前执行
//    @Override
//    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
//        System.out.println("4、执行afterCompletion");
//        super.afterCompletion(request, response, handler, ex);
//    }
}

2、重写类中的方法，

preHandle:前置拦截（进入控制器类前）
一般用于权限控制
postHandle:后置拦截（控制器类的执行以后）
一般适合进行日志记录
afterCompletion:本次请求即将结束时拦截
一般适合进行资源的关闭、释放

3、在applicationContext.xml文件中，进行配置

        <mvc:interceptors>
            <mvc:interceptor>
            <mvc:mapping path="/op/**"/>
            <bean class="org.java.util.LoginInterceptor"/>
            </mvc:interceptor>
        </mvc:interceptors>

定时任务

问题1：什么是定时任务？如何实现

答：在指定的时间，按指定的规则，去执行指定的任务，这样的任务我们就称为：“定时任务”

在java中，要实现定时任务,有如下方式：

通过java中提供的Timer(定时器)组件实现
它只能实现一些比较简单的定时任务
通过Quartz框架来实现定时任务

任务1：使用quartz实现代码重复执行3次,每间隔1秒钟执行一次（与spring无关）

1、创建java工程

2、导入相关jar

3、编写一个类实现Job接口

这个类中的代码，就是要执行的任务

package org.java.service;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * 定时任务，要完成的任务类
 */
public class RemindJobService implements Job {

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

        System.out.println("------------------定时任务开始执行----------------");
    }
}

4、编写测试类，进行测试（这个测试类实际使用时，并不存在）

        //创建一个工作详情类，用于指定，要完成具体任务的是哪一个类
        JobDetail jobDetail = new JobDetail("myJob", RemindJobService.class);

        //创建一个触发器（用于指定任务在什么时间，按照什么规则运行）
       //Trigger tr = new SimpleTrigger("mytr",-1,1000);

        //指定任务开始执行的时间
        String v1 ="2020-07-18 09:17:30";
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date begin = sf.parse(v1);

        String v2 ="2020-07-18 09:17:50";
        Date end = sf.parse(v2);


        Trigger tr = new SimpleTrigger("mytr",begin,end,-1,1000);

        //创建一个调度工厂（用于产生调度）
        SchedulerFactory  factory = new StdSchedulerFactory();

        //产生一个调度（相当于一个指挥官）
        Scheduler sc = factory.getScheduler();

        //给调度绑定任务
        sc.scheduleJob(jobDetail,tr);

        //启动调度
        sc.start();

SimpleTrigger：这种触发器，只能指定一些简单的触发的规则
CronTrigger:这种触发器，可以通过表达式编写触发器

Trigger tr = new CronTrigger("mytr", "mygroup", "* * * * * ?");    

   秒     分      小时     天       月        星期     

   *      *        *       *        *         ?

注意：表达式中应该包含6个符号，每一个符号之间，用空格来分隔，只要没有遇到空格就算1个符号

此处，以秒为例:

    * ----------------代表每1秒
    
    3 ----------------代表第3秒    
        特殊的地方：如果修饰的是星期：
                星期天----------1
                星期一----------2
                星期六----------7

    1，3，5-----------代表：第1，3，5秒

    1-5---------------代表第1-5秒

    1-5,13,15---------代表第1-5秒，以及13,15秒


    1/3 --------------代表每间隔3秒钟运行1次

?：只能出现在第4位（天）或者是第6位（星期），它仅仅代表一个占位符，没有任何实际意义

    在定时任务的表达式中，星期与天不允许同时赋值，一个赋了值，另一个，一定要用?占位


L（last）: 只能出现在第4位（天）或者是第6位（星期）

    如果修饰天，只能写成 L
        --------------------代表这个月的最后一天

    如果修饰星期，可以写成
            
            1L--------------本月的最后一个星期天
            2L--------------本月的最后一个星期一
                      .....
            7L


#:只能修饰星期
    
    6#3:表示本月的第3个星期五

任务2：在spring应用中，使用定时任务 (非web应用)

1、创建java工程

2、导入下列包：

    
    spring aop的包+ context-support  + tx

    然后加上 quartz的包(4.2)

3、编写任务类 (普通类即可)

package org.java.service;

import org.springframework.stereotype.Service;

@Service("remindJobService")
public class RemindJobService {

    public void abc(){
        System.out.println("-----------定时任务正在执行--------------");
    }

    public void show(){
        System.out.println("~~~~~~~~~~~~~show~~~~~~~~");
    }
}

4、编写applicatioinContext.xml

 <context:component-scan base-package="org.java"/>

    <!--进行定时任务的配置-->

    <!--配置工作详情类-->
    <bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <!--指定任务类-->
        <property name="targetObject" ref="remindJobService"/>
        <!--指定执行定时任务的方法-->
        <property name="targetMethod" value="abc"/>
    </bean>

    <!--指定触发器-->
    <bean id="tr" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <!--工作详情类-->
        <property name="jobDetail" ref="jobDetail"/>
        <!--触发规则-->
        <property name="cronExpression" value="* * * * * ?"/>
    </bean>

    <!--配置调度-->
    <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="tr"/>
            </list>
        </property>
    </bean>

任务3：在springmvc中，使用调度

1、创建springmvc的应用

2、导入jar

    springmvc用的所有 jar + context-support  + tx

    然后加上 quartz的包(4.2)

3、编写applicationContext

<context:component-scan base-package="org.java"/>


    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--进行定时任务的配置-->

    <!--配置工作详情类-->
    <bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <!--指定任务类-->
        <property name="targetObject" ref="jobService"/>
        <!--指定执行定时任务的方法-->
        <property name="targetMethod" value="show"/>
    </bean>

    <!--指定触发器-->
    <bean id="tr" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <!--工作详情类-->
        <property name="jobDetail" ref="jobDetail"/>
        <!--触发规则-->
        <property name="cronExpression" value="* * * * * ?"/>
    </bean>

    <!--配置调度-->
    <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="tr"/>
            </list>
        </property>
    </bean>

4、编写web.xml

<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>
    
    <servlet>
        <servlet-name>mvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>mvc</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

任务4：采用spring注解的方式配置定时任务（springboot）

这种方式使用的并不是quartz这个定时任务框架，而是使用spring自己的定时任务

1、创建web工程

2、导入下列包：

    spring aop的包+ context-support  + tx

3、编写任务类 (普通类即可)

package org.java.service;

import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
@EnableScheduling//启用调度
@Service
public class JobService {

    @Scheduled(cron ="* * * * * ?" )
    public void show(){
        System.out.println("~~~~~~~任务类正在运行~~~~~~~~~~~~~");
    }
}

4、编写applicatioinContext.xml


    <context:component-scan base-package="org.java"/>


    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <property name="suffix" value=".jsp"/>
    </bean>

无区新手

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
springmvc02

在springmvc中，实现文件上传步骤:1、创建web应用2、导入jar spring 4.2 core,beans,context,expression,aop,aspects,web,webmvc spring 3.0.2 logging, aop联盟,织入 jsp: jstl,standard 增加: co...
复制链接

扫一扫

专栏目录