ssm整合练习

最新推荐文章于 2021-06-30 20:06:24 发布

严格要求自己

最新推荐文章于 2021-06-30 20:06:24 发布

阅读量474

点赞数

CC 4.0 BY-SA版权

分类专栏： java后端框架练习文章标签：过滤器列表 mybatis spring web.xml

本文链接：https://blog.csdn.net/qq_43050847/article/details/107826374

java后端框架练习专栏收录该内容

6 篇文章

订阅专栏

文章目录

环境配置

springmvc.xml

<?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:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!--注解驱动-->
    <mvc:annotation-driven></mvc:annotation-driven>
    <!--静态资源过滤-->
    <mvc:default-servlet-handler></mvc:default-servlet-handler>
    <!--全局包扫描，只扫描controller注解-->
    <context:component-scan base-package="com.javasm" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"></context:include-filter>
    </context:component-scan>
    <!--全局跨域配置-->
    <!--<mvc:cors>-->
        <!--<mvc:mapping path="/**" allow-credentials="true" allowed-headers="*" allowed-methods="*" allowed-origins="*" exposed-headers="Set-Cookie"/>-->
    <!--</mvc:cors>-->

    <!--登录判断拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <mvc:exclude-mapping path="/admin/nameCharge"></mvc:exclude-mapping>
            <mvc:exclude-mapping path="/admin/login"></mvc:exclude-mapping>
            <bean class="com.javasm.common.interceptor.LoginInterceptor"></bean>
        </mvc:interceptor>
    </mvc:interceptors>
</beans>

spring.xml

<?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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--全局包扫描，排除controller注解-->
    <context:component-scan base-package="com.javasm">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"></context:exclude-filter>
    </context:component-scan>

    <!--aop织入-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    <!--加载mybatis-spring的配置文件-->
    <import resource="classpath:mybatis-spring.xml"></import>
</beans>

mybatis-spring.xml

<?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:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--加载jdbc资源文件-->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    <!--配置数据源对象，使用druid连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.name}"></property>
        <property name="password" value="${jdbc.pass}"></property>
    </bean>

    <!--对mapper接口创建代理对象，加入容器-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.javasm.*.mapper"></property>
    </bean>

    <!--创建全局的sqlsessionfactory对象（数据源，映射文件，别名、驼峰映射等其他配置）-->
    <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="mapperLocations" value="classpath:com/javasm/*/mapper/*.xml"></property>
        <property name="configLocation" value="classpath:mybatis.xml"></property>
        <!--配置分页插件-->
        <property name="plugins">
            <array>
                <bean class="com.github.pagehelper.PageInterceptor" id="pageInterceptor">
                    <property name="properties">
                        <!--分页参数合理化-->
                        <value>reasonable=true</value>
                    </property>
                </bean>
            </array>
        </property>
    </bean>

    <!--配置spring的事务管理器对象（打开会话，提交会话，回滚，关闭）-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--通过事务通知，把事务管理器织入到带有@Transactional注解的方法-->
    <tx:annotation-driven></tx:annotation-driven>

</beans>

mybatis.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <setting name="mapUnderscoreToCamelCase" value="true"></setting>
    </settings>

    <typeAliases>
        <package name="com.javasm"></package>
    </typeAliases>
</configuration>

jdbc.properties

jdbc.url = jdbc:mysql://127.0.0.1:3306/second_stage?characterEncoding=UTF8&useSSL=true
jdbc.name = root
jdbc.pass = root
jdbc.driver = com.mysql.jdbc.Driver

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!--跨域拦截器的配置-->
    <filter>
        <filter-name>myCrosFilter</filter-name>
        <filter-class>com.javasm.common.filter.MyCrosFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>myCrosFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!--通过ContextLoaderListener监听器在tomcat启动时，加载spring.xml文件来初始化父容器对象-->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring.xml</param-value>
    </context-param>

    <!--通过DispatcherSerlvet在tomcat启动时，加载springmvc.xml文件来初始化子容器对象，-->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!--配置中文过滤器-->
    <filter>
        <filter-name>characterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>

commons公共包

entity实体类

StatusEnum

public enum StatusEnum {

    SUCCESS(20000,"操作成功"),
    ERROR(50000,"操作失败"),
    LOGIN_ERR(50001,"用户未登录"),
    MENU_ERR(50002,"菜单列表获取失败");

    private Integer code;
    private String msg;

    StatusEnum(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

StatusBean

public class StatusBean {
    private Integer code;
    private String msg;

    public StatusBean(StatusEnum statusEnum) {
        this.code = statusEnum.getCode();
        this.msg = statusEnum.getMsg();
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }
}

ResponseBean

public class ResponseBean extends StatusBean {

    private Object data;

    public ResponseBean(StatusEnum statusEnum, Object data) {
        super(statusEnum);
        this.data = data;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }
}

interceptor拦截器

LoginInterceptor登陆拦截

public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        SysAdmin login_user = (SysAdmin) request.getSession().getAttribute("LOGIN_USER");
        if (login_user == null) {
            throw new MyException(StatusEnum.LOGIN_ERR);
//            System.out.println("执行了拦截器");
//            response.sendRedirect("http://127.0.0.1:8848/ssm/login.html");
//            return false;
        } else {
            return true;
        }
    }
}

filter过滤器

MyCrosFilter 全局跨域过滤配置

public class MyCrosFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        try {
            HttpServletRequest httpRequest = (HttpServletRequest) request;
            HttpServletResponse httpResponse = (HttpServletResponse) response;

            // 预检请求，请求头Origin是客户端地址，要求跨域头不能是*
            String origin = httpRequest.getHeader("Origin");
            if (origin == null) {
                httpResponse.addHeader("Access-Control-Allow-Origin", "*");
            } else {
                httpResponse.addHeader("Access-Control-Allow-Origin", origin);
            }
            httpResponse.addHeader("Access-Control-Allow-Headers",
                    "Origin, x-requested-with, Content-Type, Accept,X-Cookie,token");
//httpResponse.addHeader("Access-Control-Expose-Headers", "token");

            httpResponse.addHeader("Access-Control-Allow-Credentials", "true");
            httpResponse.addHeader("Access-Control-Allow-Methods", "GET,POST,PUT,OPTIONS,DELETE");
            //预检请求，直接通过。
            if (httpRequest.getMethod().equals("OPTIONS")) {
                httpResponse.setStatus(HttpServletResponse.SC_OK);
                return;
            }
            chain.doFilter(request, response);
        } catch (Exception e) {
            throw e;
        }
    }
    @Override
    public void destroy() {
    }
}

exception自定义异常

MyException

public class MyException extends RuntimeException {
    private StatusEnum statusEnum;

    public MyException(StatusEnum statusEnum) {
        this.statusEnum = statusEnum;
    }

    public StatusEnum getStatusEnum() {
        return statusEnum;
    }

    public void setStatusEnum(StatusEnum statusEnum) {
        this.statusEnum = statusEnum;
    }
}

advice 全局异常处理

ExceptionResolver

@Component
@ControllerAdvice
public class ExceptionResolver {
    @ExceptionHandler(MyException.class)
    public ResponseEntity doMyException(MyException e){
        return ResponseEntity.ok(new StatusBean(e.getStatusEnum()));
    }
}

module1模块（mybatis-generator逆向生成）

entity

handler（session、分页、增删改查）

SysAdminHandler（登录session）

@Controller
@RequestMapping("admin")
public class SysAdminHandler {

    @Autowired
    private SysAdminService adminService;

    @GetMapping("nameCharge")
    public ResponseEntity nameCharge(String nameCharge) {
        System.out.println(nameCharge);
        SysAdmin sysAdmin = adminService.selectAdminByName(nameCharge);
        if (sysAdmin == null) {
            throw new MyException(StatusEnum.ERROR);
        } else {
            sysAdmin.setApwd(""); // 设置密码为空
            return ResponseEntity.ok(new ResponseBean(StatusEnum.SUCCESS, sysAdmin));
        }
    }

    @GetMapping("login")
    public ResponseEntity loginCharge(String name, String pass, HttpServletRequest req) {
        System.out.println(name);
        System.out.println(pass);
        SysAdmin sysAdmin = adminService.selectAdminByNameAndPass(name,pass);
        if (sysAdmin == null) {
            throw new MyException(StatusEnum.ERROR);
        } else {
            HttpSession session = req.getSession();
            System.out.println(session);
            req.getSession().setAttribute("LOGIN_USER",sysAdmin); // 服务端保存会话信息
            System.out.println(req.getSession().getAttribute("LOGIN_USER"));
            return ResponseEntity.ok(new StatusBean(StatusEnum.SUCCESS));
        }
    }

}

SysMenuHandler（事务、分页、增删改查）

@Controller
@RequestMapping("menu")
public class SysMenuHandler {

    @Autowired
    private SysMenuService menuService;

    @GetMapping("getMenu")
    public ResponseEntity getMenu(HttpServletRequest req) {
        HttpSession session = req.getSession();
        System.out.println(session);

        SysAdmin loginUser = (SysAdmin) req.getSession().getAttribute("LOGIN_USER");
        if (loginUser == null) {
            throw new MyException(StatusEnum.LOGIN_ERR);
        }
        List<SysMenu> sysMenus = menuService.selectList(loginUser.getMenuId());
        if (sysMenus == null) {
            throw new MyException(StatusEnum.MENU_ERR);
        } else {
            loginUser.setApwd("");
            Map<String, Object> map = new HashMap<>();
            map.put("adminInfo", loginUser);
            map.put("menuInfo", sysMenus);
            return ResponseEntity.ok(new ResponseBean(StatusEnum.SUCCESS, map));
        }
    }

    @GetMapping("deleteMenu")
    public ResponseEntity deleteByPrimaryKey(Integer pid) {
        int result = menuService.deleteByPrimaryKey(pid);
        if (result >= 1) {
            return ResponseEntity.ok(new StatusBean(StatusEnum.SUCCESS));
        } else {
            throw new MyException(StatusEnum.ERROR);
        }
    }

    @PostMapping("updateMenu")
    public ResponseEntity updateMenu(@RequestBody SysMenu sysMenu) {
        System.out.println(sysMenu);
        int result = menuService.updateByPrimaryKeySelective(sysMenu);
        if (result >= 1) {
            return ResponseEntity.ok(new StatusBean(StatusEnum.SUCCESS));
        } else {
            throw new MyException(StatusEnum.ERROR);
        }
    }

    @PostMapping("selectMenu")
    public ResponseEntity selectMenu(@RequestBody Map<String, Object> map) throws InvocationTargetException, IllegalAccessException {
        SysMenu sysMenu = new SysMenu();
        // 菜单的条件查询项装载
        BeanUtils.populate(sysMenu, map);

        // 得到分页信息
        PageHelper.startPage((Integer) map.get("pageNum"), (Integer) map.get("pageSize"));// 1

        List<SysMenu> sysMenus = menuService.selectByInfo(sysMenu);

        // 把分页信息及数据装载进PageInfo对象
        PageInfo<SysMenu> sysMenuPageInfo = new PageInfo<SysMenu>(sysMenus); // 2

        if (sysMenus.size() != 0) {
            return ResponseEntity.ok(new ResponseBean(StatusEnum.SUCCESS, sysMenuPageInfo));
        } else {
            throw new MyException(StatusEnum.ERROR);
        }
    }

    @PostMapping("insertMenuAndAdmin")
    public ResponseEntity insertMenuAndAdmin(@RequestBody Map<String, Object> map) throws InvocationTargetException, IllegalAccessException {
        System.out.println(map);
        SysMenu sysMenu = new SysMenu();
        SysAdmin admin = new SysAdmin();
        BeanUtils.populate(sysMenu, map);
        BeanUtils.populate(admin, map);
        System.out.println(sysMenu);
        System.out.println(admin);

        int result = menuService.insertMenuAndAdmin(admin, sysMenu);
        if (result >= 1) {
            return ResponseEntity.ok(new StatusBean(StatusEnum.SUCCESS));
        } else {
            throw new MyException(StatusEnum.ERROR);
        }
    }
}

service部分截取（事务）

@Service
public class SysMenuServiceImpl implements SysMenuService {

    @Autowired
    private SysMenuMapper menuMapper;
    @Autowired
    private SysAdminMapper adminMapper;

    /**
     * 多表插入，事务注解
     *
     * @param admin
     * @param sysMenu
     * @return
     */
    @Override
    @Transactional
    public int insertMenuAndAdmin(SysAdmin admin, SysMenu sysMenu) {
        int result = 0;
        try {
            result = menuMapper.insertSelective(sysMenu);
            result = adminMapper.insert(admin);
        } catch (Exception e) {
            throw new MyException(StatusEnum.ERROR);
        }
        return result;
    }
}

mapper

前端axios-config.js全局配置

axios.defaults.baseURL = 'http://localhost:8080/0804/';
axios.defaults.withCredentials = true; //跨域配置

// //配置发送请求前的拦截器 可以设置token信息 
//    axios.interceptors.request.use(
//         config => {
//           return config
//        }, error => {
//           return Promise.reject(error)
//        }
//     )

// 配置响应拦截器 
axios.interceptors.response.use(
	res => {
		if(res.data.code == 50001){
			// 说明用户未登录
			location.href = "http://127.0.0.1:8848/ssm/login.html";
		}
		
		return Promise.resolve(res.data) // 这里直接返回data, 即接口返回的所有数据
	},
	error => {
		return Promise.reject(error);
	}
)