栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

SSM框架(Spring、Springmvc、Mybatis)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

SSM框架(Spring、Springmvc、Mybatis)

SSM框架——暑假实训日志 Java高级技术 请求和响应:
  1. request:从页面向服务器传递数据(参数)

  2. response:

    1)数据库响应:返回数据库交互后的结果

    2)web服务器响应:返回页面及业务相关的数据模型

转发和重定向
request.getRequestDispatcher("wellCome.jsp").forward(request,response);//转发(服务器内部行为):1.页面间数据共享,还是同一个请求对象。2.地址栏不变
response.sendRedirect("formTest.jsp");//重定向(可重定向到外部服务器):重新发起一次请求,上一次请求的数据会丢失。同时重定向之后地址栏会改变
String uname = request.getParameter("uname");
String pass = request.getParameter("pass");

if ("lucky".equals(uname)&&"123456".equals(pass)){
    request.getRequestDispatcher("wellCome.jsp").forward(request,response);//转发(服务器内部行为):1.页面间数据共享,还是同一个请求对象。2.地址栏不变
}else {
    //session.setAttribute("user",uname);
    //如果在重定向后依然需要重新获取请求的数据,可以用session或cookie。
    // session会话的结束是在浏览器的开启与结束,同时不同浏览器会话会不同。与窗口,转发,重定向无关。
    // 但是,session浪费浏览器资源,session保存在客户端。作用域范围session>request


    session.setAttribute("errorMsg","用户名或密码错误!");

    response.sendRedirect("formTest.jsp");//重定向(可重定向到外部服务器):重新发起一次请求,上一次请求的数据会丢失。同时重定向之后地址栏会改变
    //response.sendRedirect("error.jsp");


}
er表达式获取:${param:uname}
<%--<%=request.getSession().getId()%>--%>
<%--session会话--%>
<%
    String uname = request.getParameter("uname");
%>
你好:<%=uname%>
<%--欢迎${param:uname}>--%>
cookie内容:

loginInfo.jsp

if ("lucky".equals(uname)&&"123456".equals(pass)){
    Cookie cookie = new Cookie("token",uname);

    //cookie内容
    response.addCookie(cookie);//把cookie增加到客户端(浏览器)
    response.sendRedirect("wellCome.jsp");//重定向获得下一次请求

    //转发内容
    //request.getRequestDispatcher("wellCome.jsp").forward(request,response);//转发(服务器内部行为):1.页面间数据共享,还是同一个请求对象。2.地址栏不变

}

wellcome.jsp

<%--cookie内容--%>
<%
    Cookie[] cookies = request.getCookies();
    System.out.println(cookies);
    if (cookies.length>0&&cookies!=null){//使逻辑紧凑
        for (Cookie c:cookies) {//增强for循环方式
            System.out.println(c.getValue());//cookie可以保存session的id
        }
    }
%>
JDBC和MySQL
接口:
connection:连接数据库的
prepelestatment:编译之后的
resultset:结果集
三层架构


jsp执行过程:

翻译成.java,编译成.class

其中.java就是servlet,即jsp会翻译成servlet

servlet httpservlet.class:

7种http请求方法:

private static final String METHOD_DELETE = "DELETE";
private static final String METHOD_HEAD = "HEAD";
private static final String METHOD_GET = "GET";
private static final String METHOD_OPTIONS = "OPTIONS";
private static final String METHOD_POST = "POST";
private static final String METHOD_PUT = "PUT";
private static final String METHOD_TRACE = "TRACE";

httpservlet中的service:

获取请求方式:String method = req.getMethod();//doget、dopost

protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    String method = req.getMethod();
    long lastModified;
    if (method.equals("GET")) {
        lastModified = this.getLastModified(req);
        if (lastModified == -1L) {
            this.doGet(req, resp);
        } else {
            long ifModifiedSince;
            try {
                ifModifiedSince = req.getDateHeader("If-Modified-Since");
            } catch (IllegalArgumentException var9) {
                ifModifiedSince = -1L;
            }

            if (ifModifiedSince < lastModified / 1000L * 1000L) {
                this.maybeSetLastModified(resp, lastModified);
                this.doGet(req, resp);
            } else {
                resp.setStatus(304);
            }
        }
    } else if (method.equals("HEAD")) {
        lastModified = this.getLastModified(req);
        this.maybeSetLastModified(resp, lastModified);
        this.doHead(req, resp);
    } else if (method.equals("POST")) {
        this.doPost(req, resp);
    } else if (method.equals("PUT")) {
        this.doPut(req, resp);
    } else if (method.equals("DELETE")) {
        this.doDelete(req, resp);
    } else if (method.equals("OPTIONS")) {
        this.doOptions(req, resp);
    } else if (method.equals("TRACE")) {
        this.doTrace(req, resp);
    } else {
        String errMsg = lStrings.getString("http.method_not_implemented");
        Object[] errArgs = new Object[]{method};
        errMsg = MessageFormat.format(errMsg, errArgs);
        resp.sendError(501, errMsg);
    }

}

HelloServlet

@WebServlet("/HelloServlet")
//反射:@WebServlet("/HelloServlet")
public class HelloServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        System.out.println("post...");
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        System.out.println("get...");
    }

    protected void service(HttpServletRequest req, HttpServletResponse resp){
        System.out.println("执行了service");
    }
}

servlet配置文件

和反射注解是一个意思//反射:@WebServlet("/HelloServlet")

servlet标签:
 
    FirstServlet
  com.pxy.servlet.FirstServlet
 

servlet映射:
目的:和对象进行绑定,注解也是这个作用
 
    FirstServlet
  /FirstServlet

过滤器Filter

Servlet过滤器主要用于对客户端浏览器的请求进行过滤处理

//过滤器特点:前置处理:请求到达目标资源之前可以处理请求
//@WebFilter("/HelloFilter")
@WebFilter("/HelloServlet")

public class HelloFilter implements Filter {
    public void destroy() {
    }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
//        HttpServletRequest request = (HttpServletRequest) req;
//        HttpServletResponse response = (HttpServletResponse) resp;
//        ((HttpServletRequest) req).getRequestURI();
//        session.getAtrebute("user")!=null;
        System.out.println("前置处理");

        chain.doFilter(req, resp);//回调函数,把请求继续向下传递
        System.out.println("后置处理");
    }

    public void init(FilterConfig config) throws ServletException {

    }

}

监听器

监听器用于监听Web容器的有效期事件,因此它由容器管理。利用Listener接口监听在容器中的某个执行程序,并且根据其应用的需求做出适当的响应。

web.xml



    com.ctgu.listener.Mylistener

Mylistener

public class Mylistener implements HttpSessionListener {
    @Override
    public void sessionCreated(HttpSessionEvent httpSessionEvent) {
        System.out.println("session创建");
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent httpSessionEvent) {
        System.out.println("session销毁");
    }
}
EL表达式

User实体类

public class Tuser {
    private String name;
    private int pass;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPass() {
        return pass;
    }

    public void setPass(int pass) {
        this.pass = pass;
    }

    @Override
    public String toString() {
        return "Tuser{" +
                "name='" + name + ''' +
                ", pass=" + pass +
                '}';
    }
}

ElServlet

@WebServlet("/ElServlet")
public class ElServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        Tuser user = new Tuser();
        user.setName("admin");
        request.setAttribute("str","stringValue");
        request.setAttribute("user",user);
        request.getRequestDispatcher("ElTest.jsp").forward(request,response);
    }
}

ElTest.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    el



    普通对象:${user.name}
    String字符串:${str}


JSTL表达式

ElTest.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>


    el



    普通对象:${user.name}

    
    String字符串:${str}


ElServlet

public class ElServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        Tuser user = new Tuser();
        user.setAge(18);
        request.setAttribute("str","stringValue");
        request.setAttribute("user",user);
        request.getRequestDispatcher("ElTest.jsp").forward(request,response);
    }
}
Ajax

页面局部刷新

异步:发送请求后不等返回结果,由回调函数处理结果

ajaxTest.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    ajax
    








RegServlet.java

@WebServlet("/regTest")
public class RegServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String uname = request.getParameter("userName");
        response.setCharacterEncoding("utf-8");
        String msg = "";
        if("admin".equals(uname)){
            msg="用户名已被注册";
        }else {
            msg="用户名可用";
        }
        response.getWriter().write(msg);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }
}
Spring SpringIOC

IOC(程序设计思维):由Spring帮我们创建对象,不用我们自己创建了。直接用接口实现类即可,不需要硬编码。

spring创建对象–》写xml配置文件

spring帮助我们创建对象过程–>IOC

1.项目结构–>导包lib

2.创建接口

public interface Dao {

    void updatePojo();
}
public interface TuserService {
    void changeTuser();
}

3.创建类

public class MysqlDao implements Dao{
    @Override
    public void updatePojo() {
        System.out.println("mysql数据库工作。。");
    }

    public MysqlDao(){
        System.out.println("mysql实例化");
    }
}
public class OracleDao implements Dao{
    @Override
    public void updatePojo() {
        System.out.println("oracl数据库工作。。");

    }

    public OracleDao(){
        System.out.println("oracle实例化");
    }
}
public class TuserServiceImpl implements TuserService{


   // private Dao dao= new OracleDao();//硬编码,会写死
    private Dao dao;

    public Dao getDao() {
        return dao;
    }

    public void setDao(Dao dao) {
        this.dao = dao;
    }

    @Override
    public void changeTuser() {
        dao.updatePojo();
    }

    public TuserServiceImpl(){//无参构造器
        System.out.println("tuserServiceImpl实例化");
    }

    public static void main(String[] args) {
        //让spring容器帮助我们创建对象
        //创建对象的过程 = 类的实例化 = new + 构造器   -->调用构造器   -->需要无参构造器
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
    }
}

4.配置xml

application.xml




    
    
    
    
    


5.无参实例化

public TuserServiceImpl(){//无参构造器
    System.out.println("tuserServiceImpl实例化");
}

public static void main(String[] args) {
    //让spring容器帮助我们创建对象
    //创建对象的过程 = 类的实例化 = new + 构造器   -->调用构造器   -->需要无参构造器
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
}
依赖注入

注解(其实是一种反射)

1.xml






    
    


    

    
    
    
    


2.Impl

package com.ctgu.service;

import com.ctgu.dao.Dao;
import com.ctgu.dao.OracleDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class TuserServiceImpl implements TuserService{


   // private Dao dao= new OracleDao();//硬编码,会写死

    @Autowired
    
    private Dao dao;

    

    @Override
    public void changeTuser() {
        dao.updatePojo();
    }

    public TuserServiceImpl(){//无参构造器
        System.out.println("tuserServiceImpl实例化");
    }

    public static void main(String[] args) {
        //让spring容器帮助我们创建对象
        //创建对象的过程 = 类的实例化 = new + 构造器   -->调用构造器   -->需要无参构造器
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
    }
}

@Autowired按类型装配,如果一个类型有多个实例,需要#Qualifier指定名称;将容器中的实例交给引用,相当于getset

@Resource按照名称装配,如果找不到指定名称则按类型装配

组件注解–>可以不用写bean–>创建对象(相当于bean)

@Service用于标注业务层组件、 @Controller用于标注控制层组件(如struts中的action)、@Repository用于标注数据访问组件,即DAO组件。而@Component泛指组件,当组件不好归类的时候,我们可以使用这个注解进行标注。

1.@Service

@Service
public class TuserServiceImpl implements TuserService{


   // private Dao dao= new OracleDao();//硬编码,会写死

    @Autowired
    

    
    private Dao dao;

    

    @Override
    public void changeTuser() {
        dao.updatePojo();
    }

    public TuserServiceImpl(){//无参构造器
        System.out.println("tuserServiceImpl实例化");
    }

    public static void main(String[] args) {
        //让spring容器帮助我们创建对象
        //创建对象的过程 = 类的实例化 = new + 构造器   -->调用构造器   -->需要无参构造器
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
//      TuserServiceImpl service = (TuserServiceImpl) applicationContext.getBean("tuserService");
        TuserServiceImpl service = (TuserServiceImpl) applicationContext.getBean("tuserServiceImpl");
        service.changeTuser();
    }
}

2.@Repository

@Repository
public class MysqlDao implements Dao{
    @Override
    public void updatePojo() {
        System.out.println("mysql数据库工作。。");
    }

    public MysqlDao(){
        System.out.println("mysql实例化");
    }
}
SpringAOP

AOP作用:可以将核心业务以外的功能独立出来,在恰当的时机调用

高度模块化,使得我们的系统更易实现和更易维护

AOP代理

Spring缺省使用JAVA 动态代理(dynamic proxies)来作为AOP的代理。这样任何接口都可以被代理。Spring也支持使用CGLIB代理。

代理模式:外卖、房产中介

静态代理:

StaticProxy.java

//静态代理类:必须实现和目标(此接口的实现类)一样的接口
public class StaticProxy implements TuserService {
    //目标类引用
    private TuserService target;
    
    //目标类初始化
    public StaticProxy(TuserService target) {
        this.target = target;
    }
    public StaticProxy() {
        
    }
    //目标方法调用
    
    @Override
    public void changeTuser() {
        
    }

    @Override
    public void proxyTest() {
        System.out.println("前置处理:安全验证");
        target.proxyTest();//目标对象调用自己的方法
        System.out.println("后置处理:日志打印");

    }

    public static void main(String[] args) {
        TuserService tuserService = new TuserServiceImpl();
        StaticProxy proxy = new StaticProxy(tuserService);
        proxy.proxyTest();
    }
}
动态代理

InvocHandler

public class InvocHandler implements InvocationHandler {
    //目标对象引用的声明
    private Object target;
    //创建代理对象
    public Object getProxyInstance(Object target){
        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);

    }
    //调用目标方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("前置处理:安全通过");
        Object object = method.invoke(target,args);//目标方法执行
        System.out.println("后置处理:日志通过");
        return object;
    }

    public static void main(String[] args) {
        TuserService tuserService = new TuserServiceImpl();
        InvocHandler handler = new  InvocHandler();
        TuserService proxy1 = (TuserService) handler.getProxyInstance(tuserService);
        proxy1.proxyTest();

    }
}
AOP编程(基于注解方式)

基于注解方式声明切面

application.xml






    
    
    


    
    
    
    


AdviceTest.java

package com.ctgu.advice;

import com.ctgu.service.TuserService;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;

@Component
@Aspect
//定义切面
public class AdviceTest {
    

    //切入点要拦截的类
    @Pointcut("execution (* com.ctgu.service..*.*(..))")
    private void anyMethod(){} //声明一个切入点,切入点的名称其实是一个方法

     //前置通知(不需要获取输入参数)
     @Before("anyMethod()")//第一个参数为切入点的名称
     public void doAccessCheck(){
       System.out.println("前置通知:安全检测。。");
     }

     //后置通知(不需要获取返回值)
     @AfterReturning("anyMethod()")
     public void doAfterReturning(){
        System.out.println("后置通知:");
    }

     //例外通知(不需要异常信息)
     @AfterThrowing("anyMethod()")
    public void doAfterThrowing(){
        System.out.println("例外通知");
     }

     //最终通知
    @After("anyMethod()")
     public void doAfter(){
        System.out.println("最终通知:日志打印");
     }

     //环绕通知(特别适合做权限系统)
     @Around("anyMethod()")
     public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("环绕通知进入方法");
         Object object=pjp.proceed();
         System.out.println("环绕通知退出方法");
         return object;
     }


    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
        TuserService tuserService = (TuserService) applicationContext.getBean("tuserServiceImpl");
        tuserService.proxyTest();
    }
}
Mybatis

Mybatis是一个数据持久层(ORM)框架。把实体类和SQL语句之间建立了映射关系,是一种半自动化的ORM实现。

项目演练

pom.xml



    
        org.mybatis
        mybatis
        
        3.4.2
    

    
    
        mysql
        mysql-connector-java
        5.1.47
    


    
        org.slf4j
        slf4j-log4j12
        1.7.2
    

    
        org.mybatis.generator
        mybatis-generator-core
        1.3.2
    

    
        org.mybatis.caches
        mybatis-ehcache
        1.0.2
    
    
        net.sf.ehcache
        ehcache
        2.10.1
    




    
        
            src/main/java
            
                **

    @RequestMapping("/login.action")
    public String login(Tuser tuser) {
        System.out.println(tuser);
        return "index.jsp";
    }
}
自定义参数绑定

根据业务需求使用自定义参数绑定。
需要向处理器适配器中注入自定义的参数绑定组件。
对于controller形参中pojo对象,如果属性中有日期类型,需要自定义参数绑定。
将请求日期数据串转成日期类型,要转换的日期类型和pojo中日期属性的类型保持一致。

拦截器

Spring Web MVC 的处理器拦截器类似于Servlet 开发中的过滤器Filter,用于对处理器进行预处理和后处理。

定义拦截器
实现HandlerInterceptor接口
接口中提供三个方法

配置全局拦截器
springmvc配置全局的拦截器,springmvc框架将配置的全局的拦截器注入到每个HandlerMapping中。
在springmvc.xml中配置

HelloInterceptor

public class HelloInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {

        System.out.println("前置处理。。。");
        return false;
    }

    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {

    }

    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {

    }
}

springmvc.xml


   
      
      
   

文件上传

可通过form表单上传文件对象,通过Spring配置解析,存储图片文件
文件上传实现步骤:
导入jar包
创建虚拟目录
配置解析器
编写controller代码
编写页面代码

导入jar包

在pom.xml中配置依赖包

配置虚拟目录

在tomcat上配置图片虚拟目录,在tomcat下conf/server.xml中添加

docbase指定文件存储路径(D:images本地要先建立)
配完启动tomcat,可通过localhost:8080/upload/文件名,访问存储的文件

1.1.在tomcatconfigserver.xml中配置path=“/upload” 虚拟路径E:photoupload 图片存放的真实路径

1.2.将Deploy applications configured in Tomcat instance勾上

配置解析器

在springmvc.xml中配置


  commons-fileupload
  commons-fileupload
  1.2.2


  commons-io
  commons-io
  2.4


编写controller代码


编写页面代码


json数据交互

json 数据交互步骤
导入jar包
配置json转换器
编写页面代码
编写controller代码

环境搭建 导入依赖的jar包

  org.codehaus.jackson
  jackson-core-asl
  1.9.13


  org.codehaus.jackson
  jackson-mapper-asl
  1.9.13

导入jquery文件

静态资源放行

静态文件,前端控制器(拦截问题,同时clean再配置到traget中

配置json转换器

在springmvc.xml中配置

如果使用 则不用定义上边的内容。(推荐使用该方法)

json数据交互 jsp 页面(页面代码)


编写controller代码

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/957269.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号