项目知识点-Spring-jdbc-过滤器登录-aop事务

已于 2023-09-19 15:31:49 修改
阅读量586 收藏 4
点赞数
分类专栏： # Dengfl_99 文章标签： java 开发语言
于 2023-08-12 16:41:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dengfengling999/article/details/132250300
版权

 （1）Spring-jdbc 基础

Java程序使用JDBC接口访问关系数据库的时候，需要以下几步：

  • 创建全局DataSource实例，表示数据库连接池；
  • 在需要读写数据库的方法内部，按如下步骤访问数据库：
  • 从全局DataSource实例获取Connection实例；
  • 通过Connection实例创建PreparedStatement实例；
  • 执行SQL语句，如果是查询，则通过ResultSet读取结果集，如果是修改，则获得int结果。

正确编写JDBC代码的关键是使用try ... finally释放资源，涉及到事务的代码需要正确提交或回滚事务。

在Spring使用JDBC，首先我们通过IoC容器创建并管理一个DataSource实例，然后，Spring提供了一个JdbcTemplate，可以方便地让我们操作JDBC，因此，通常情况下，我们会实例化一个JdbcTemplate。顾名思义，这个类主要使用了Template模式。

 

1.使用druid连接池 

使用properties配置文件：

driverClassName= com.mysql.cj.jdbc.Driver
url= jdbc:mysql://localhost:3306/book?useSSL=true&setUnicode=true&charsetEncoding=UTF-8&serverTimezone=GMT%2B8
username= root
password= 123456
#初始化链接数量
initialSize=5
#最大链接数
maxActive=10
#最大等待时间
maxWait=3000

工具类：

package com.util;


import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;


public class JDBCUtils {
    //定义成员变量
    private static DataSource ds = null;
    //定义静态代码块
    static {
        try {
            //加载配置文件
            Properties pro = new Properties();
            pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
            //获取DataSource
            ds = DruidDataSourceFactory.createDataSource(pro);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //获取链接
    public static Connection getConnection() throws SQLException{
        return ds.getConnection();
    }
    //释放资源
    public static void close(Statement stmt,Connection conn){
        if (stmt != null){
            try {
                stmt.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (conn != null){
            try {
                conn.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
    public static void close(ResultSet rs,Statement stmt,Connection conn){
        if (rs != null){
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        close(stmt,conn);
    }
    //获取链接池方法
    public static  DataSource getDataSource(){
        return ds;
    }
}

Dao接口： 

 dao实现类：

查询：

 //定义sql
            String sql = "select * from user where username = ? and password = ?";
//执行sql
            User user1 = template.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), user.getUsername(), user.getPassword());

 增加：

 //定义sql
String sql ="insert into user values(null,?,?)";
//执行sql
int update = template.update(sql, user.getUsername(), user.getPassword());

删除：

 //定义sql
        String sql = "delete from shopping where id = ?";
 //执行sql
        int update = template.update(sql, id);

修改：

//定义sql
        String sql ="update books set img = ? , name = ? , price = ? , classly = ? , detail = ? where id = ?";
        //执行sql
        int update = template.update(sql, books.getImg(), books.getName(), books.getPrice(), books.getClassly(), books.getDetail(), books.getId());
       

package com.dao;

import com.domain.Admin;
import com.domain.Books;
import com.domain.Shopping;
import com.domain.User;
import com.util.JDBCUtils;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.concurrent.TimeoutException;

public class DaoImpl implements Dao {
    //使用JdbcTemplate
    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
    //用户登录
    @Override
    public User login(User user) {
        try {
            //定义sql
            String sql = "select * from user where username = ? and password = ?";
            //执行sql
            User user1 = template.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), user.getUsername(), user.getPassword());
            //返回结果
            return user1;
        } catch (DataAccessException e) {
            e.printStackTrace();
            return null;
        }
    }
    //用户注册
    @Override
    public int addUser(User user) {
        try {
            //定义sql
            String sql ="insert into user values(null,?,?)";
            //执行sql
            int update = template.update(sql, user.getUsername(), user.getPassword());
            return update;
        } catch (DataAccessException e) {
            e.printStackTrace();
            return 0;
        }
    }
    //遍历图书
    @Override
    public List<Books> selectBooks(String classly) {
        //定义sql
        String sql = "select * from books where classly = ?";
        //执行sql
        List<Books> query = template.query(sql, new RowMapper<Books>() {
            @Override
            public Books mapRow(ResultSet resultSet, int i) throws SQLException {
                Books b = new Books();
                b.setImg(resultSet.getString("img"));
                b.setName(resultSet.getString("name"));
                b.setPrice(resultSet.getInt("price"));
                b.setDetail(resultSet.getString("detail"));
                return b;
            }
        }, classly);
        return query;
    }
    //添加图书
    @Override
    public int addBook(Books books) {
        try {
            //定义sql
            String sql = "insert into books values(null,?,?,?,?,?)";
            //执行sql
            int update = template.update(sql, books.getImg(),
                    books.getName(), books.getPrice(),
                    books.getClassly(), books.getDetail());
            //返回值
            return update;
        } catch (DataAccessException e) {
            e.printStackTrace();
            return 0;
        }
    }
    //查询图书详情
    @Override
    public Books selectDetail(String name) {
        //定义sql
        String sql ="select * from books where name = ?";
        //执行sql
        Books query = template.queryForObject(sql, new BeanPropertyRowMapper<Books>(Books.class), name);
        //返回
        return query;
    }
    //加入购物车
    @Override
    public int addShopping(Shopping shopping) {
        try {
            //定义sql
            String sql = "insert into shopping values(null,?,?,?,?,?)";
            int update = template.update(sql,shopping.getImg(), shopping.getUsername(), shopping.getName(), shopping.getNumber(), shopping.getPrice());
            //返回值
            return update;
        } catch (DataAccessException e) {
            e.printStackTrace();
            return 0;
        }
    }
    //遍历购物车
    @Override
    public List<Shopping> selectShopping(String username) {
        //定义sql
        String sql = "select * from shopping where username = ?";
        List<Shopping> query = template.query(sql, new RowMapper<Shopping>() {
            @Override
            public Shopping mapRow(ResultSet resultSet, int i) throws SQLException {
                Shopping shopping = new Shopping();
                shopping.setId(resultSet.getInt("id"));
                shopping.setImg(resultSet.getString("img"));
                shopping.setName(resultSet.getString("name"));
                shopping.setNumber(resultSet.getInt("number"));
                shopping.setPrice(resultSet.getInt("price"));
                return shopping;
            }
        }, username);
        return query;
    }
    //删除购物车
    @Override
    public int deleteShopping(int id) {
        //定义sql
        String sql = "delete from shopping where id = ?";
        //执行sql
        int update = template.update(sql, id);
        //返回执行结果
        return update;
    }
    //清空购物车
    @Override
    public int deleteS(String username) {
        //定义sql
        String sql = "delete from shopping where username = ?";
        //执行sql
        int update = template.update(sql, username);
        //返回执行结果
        return update;
    }
    //管理员登录
    @Override
    public Admin admin(Admin admin) {
        try {
            //定义sql
            String sql = "select * from admin where username = ? and password = ?";
            //执行sql
            Admin admin1 = template.queryForObject(sql, new BeanPropertyRowMapper<Admin>(Admin.class), admin.getUsername(), admin.getPassword());
            return admin1;
        } catch (DataAccessException e) {
            e.printStackTrace();
            return null;
        }
    }
    //遍历图书
    @Override
    public List<Books> BOOKS_LIST() {
        //定义sql
        String sql ="select * from books";
        //执行sql
        List<Books> query = template.query(sql, new RowMapper<Books>() {
            @Override
            public Books mapRow(ResultSet resultSet, int i) throws SQLException {
                Books b = new Books();
                b.setId(resultSet.getInt("id"));
                b.setImg(resultSet.getString("img"));
                b.setName(resultSet.getString("name"));
                b.setPrice(resultSet.getInt("price"));
                b.setClassly(resultSet.getString("classly"));
                b.setDetail(resultSet.getString("detail"));
                return b;
            }
        });
        return query;
    }
    //删除图书
    @Override
    public int deleteBooks(String name) {
        //定义sql
        String sql = "delete from books where name = ?";
        //执行sql
        int update = template.update(sql, name);
        //返回
        return update;
    }
    //修改图书
    @Override
    public int modifyBook(Books books) {
        //定义sql
        String sql ="update books set img = ? , name = ? , price = ? , classly = ? , detail = ? where id = ?";
        //执行sql
        int update = template.update(sql, books.getImg(), books.getName(), books.getPrice(), books.getClassly(), books.getDetail(), books.getId());
        //返回
        return update;
    }
    //遍历用户
    @Override
    public List<User> selectUser() {
        //定义sql
        String sql ="select * from user";
        //执行sql
        List<User> query = template.query(sql, new RowMapper<User>() {
            @Override
            public User mapRow(ResultSet resultSet, int i) throws SQLException {
                User u = new User();
                u.setId(resultSet.getInt("id"));
                u.setUsername(resultSet.getString("username"));
                u.setPassword(resultSet.getString("password"));
                return u;
            }
        });
        return query;
    }
    //修改用户
    @Override
    public int modifyUser(User user) {
        //定义sql
        String sql = "update user set username = ? , password = ? where id = ?";
        //执行sql
        int update = template.update(sql, user.getUsername(), user.getPassword(), user.getId());
        //返回
        return update;
    }

    @Override
    public int deleteUser(int id) {
        //定义sql
        String sql ="delete from user where id =?";
        //执行sql
        int update = template.update(sql, id);
        return update;
    }
}

（2）过滤器实现登录

package com.demo;

import com.dao.Dao;
import com.dao.DaoImpl;
import com.domain.User;
import org.apache.commons.beanutils.BeanUtils;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;

@WebServlet("/loginServlet")
public class LoginServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //设置编码格式
        request.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=utf-8");
        //获取数据
        Map<String, String[]> map = request.getParameterMap();
        //封装数据
        User user = new User();
        try {
            BeanUtils.populate(user,map);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        //调用dao
        Dao dao = new DaoImpl();
        User login = dao.login(user);
        if (login != null){
            HttpSession session = request.getSession();
            session.setAttribute("username",user.getUsername());
            response.sendRedirect(request.getContextPath()+"/indexServlet?classly=1");
        }else {
            request.setAttribute("user","账号或密码错误");
            request.getRequestDispatcher("login.jsp").forward(request,response);
        }
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
}

简单的过滤器实现：判断用户是否登录，登录就放行

package com.listener;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

/**
 * 登录验证的过滤器
 */
@WebFilter("/*")
public class LoginFilter implements Filter {
    public void destroy() {
    }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        //强制转换
        HttpServletRequest request = (HttpServletRequest) req;
        //1.获取资源请求路径
        String uri = request.getRequestURI();
        //2.判断是否包含登录相关资源路径,要注意排除掉css/图片/js等资源
        if (uri.contains("/login.jsp") || uri.contains("/loginServlet")||
                uri.contains("/login2.jsp")||uri.contains("/login2Servlet") ||
                uri.contains("/css/") || uri.contains("/img/") ||
                uri.contains("adlogin.jsp") || uri.contains("/adLoginServlet")){
            //包含，用户就是想登录，放行
            chain.doFilter(req, resp);
        }else {
            //不包含，需要验证用户是否登录
            //3.从获取session中获取username
            Object username = request.getSession().getAttribute("username");
            if (username != null){
                //登录了，放行
                chain.doFilter(req,resp);
            }else {
                //没有登录，跳转登录页面
                request.setAttribute("user","您尚未登录，请登录");
                request.getRequestDispatcher("/login.jsp").forward(request,resp);
            }

        }
        //chain.doFilter(req, resp);
    }

    public void init(FilterConfig config) throws ServletException {

    }

}

（3）项目Spring中用的aop事务的写法

 <!--加载事务管理器-->
    <bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--加载数据源连接池-->
        <property name="dataSource" ref="druidDataSource"/>
    </bean>

    <!--配置事务增强通知-->
    <!--transaction-manager加载指定的事务管理器-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--事务规则列表-->
        <tx:attributes>
            <!--propagation定义动作的规则-->
            <!--REQUIRED阻断操作-->
            <!--NOT_SUPPORTED非阻断操作-->
            <!--对新增数据操作的规则定义-->
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="add*" propagation="REQUIRED"/>
            <!--对修改数据操作的规则定义-->
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="edit*" propagation="REQUIRED"/>
            <!--对删除数据操作的规则定义-->
            <tx:method name="delete*" propagation="REQUIRED"/>
            <!--对查询数据操作的规则定义-->
            <tx:method name="get*" propagation="NOT_SUPPORTED"/>
            <tx:method name="select*" propagation="NOT_SUPPORTED"/>
            <tx:method name="query*" propagation="NOT_SUPPORTED"/>
        </tx:attributes>
    </tx:advice>

    <!--托管通知工具类-->
    <bean name="advice" class="com.example.meal_ordering_system.util.AdviceUtil"/>

    <!--切面的配置-->
    <aop:config>
        <!--切面定义在Service层-->
        <aop:pointcut id="pointCut" expression="execution(* com.example.meal_ordering_system.service..*(..))"/>
        <!--将事务增强通知与切面进行绑定-->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointCut"/>
        <!--切面织入-->
        <aop:aspect ref="advice">
            <aop:before method="before" pointcut-ref="pointCut"/>
            <aop:after method="after" pointcut-ref="pointCut"/>
            <aop:around method="around" pointcut-ref="pointCut"/>
            <aop:after-throwing method="exception" pointcut-ref="pointCut"/>
        </aop:aspect>
    </aop:config>

喵俺第一专栏
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
spring session mysql_如何将Spring Session与JDBC结合使用？ | Java Development Journal
weixin_39880490的博客
02-04 866
在本文中，我们将了解如何将Spring Session与JDBC结合使用。Spring Session提供了一种解决HTTP会话限制的透明方法。它提供中央会话管理，而不依赖于特定于容器的解决方案(例如Tomcat，Jetty等)。它提供了存储和管理会话信息的不同选项。在本文中，我们将介绍将JDBC与Spring Session集成的步骤。如果您使用的是Spring Boot，则需要在应用程序...
使用Spring Session和JDBC DataStore进行会话管理
最佳 Java 编程
06-08 1929
在Web应用程序中，用户会话管理对于管理用户状态至关重要。 在本文中，我们将学习在集群环境中管理用户会话所遵循的方法，以及如何使用Spring Session以更加简单和可扩展的方式实现它。 通常在生产环境中，我们将有多个服务器节点，并在它们前面有一个负载平衡器，并且所有客户端流量都将通过负载平衡器到达其中一个服务器节点。 因此，我们需要某种机制来使用户会话数据可用于集群环境中的每个客户...
jdbc项目.zip
07-19
此文件为jdbc连接数据库的小项目，主要功能有用户的登录、用户的注册，以及进行用户管理，数据的增删改查以及模糊查询等功能。文件包括整个项目文件及两个表的sql文件。
jdbc经典教程+项目案例
04-19
1、本课程讲解了JDBC技术的基本技术以及statement、preparedstatement、对存储过程的调用、事物控制、批处理、处理结果、数据库连接池、代码生成器、元数据以及项目实战等经典案例； 2、本课程提供所有代码笔记素材以及其他相关资料
jdbc小项目
最新发布
2202_75792111的博客
06-01 327
jdbc.properties文件（设置在resources中）切记：密码要正确 否则会报出。读取配置文件、加载配置文件内容、加载驱动。② 如果使用数据库连接。获得连接 释放资源。2、添加web项目 (src/main)servlet层 接受请求并控制跳转。service层 业务....写项目中遇到的问题：①重新部署子工程。JdbcUtils类。3、准备一些工具类及文件。注意：配置web.xml。③如果web没有小蓝点。dao层 写sql。
2、Spring Session-使用JDBC的HttpSession
Ron.Zheng
09-19 9047
使用JDBC的HttpSession在使用HttpSession的任何功能之前通过添加一个Servlet过滤器，就可以启用Spring Session，可以通过如下几种方式进行启用： 基于Java的配置 基于XML的配置 基于Spring Boot的配置
一个Spring Session JDBC例子
canduecho的专栏
07-16 1033
它提供了与Spring框架和Spring Boot集成的简单配置，使您可以轻松地将会话数据存储在数据库中，并使用Spring的会话管理功能来管理和共享会话。通过将会话数据存储在关系型数据库中，Spring Session JDBC提供了可扩展和持久的会话管理解决方案，适用于需要在多个应用程序实例之间共享会话数据的场景。首先，创建一个名为`session`的数据库，并在其中创建一个名为`spring_session`的表，用于存储会话数据。4. 会话共享：在分布式环境中共享会话数据。
spring-aop.rar_java aop_spring aop
09-23
【标题】"spring-aop.rar_java aop_spring aop" 涉及的主要知识点是Spring框架中的面向切面编程（AOP）以及Java基础知识。这个压缩包可能包含了一个简单的Spring AOP应用示例，同时也涵盖了Java的一些核心概念，如...
spring-framework-master src 源码
10-19
这里我们将详细探讨Spring源码中的关键知识点。 1. **模块结构** Spring框架由多个模块组成，包括Core Container（核心容器）、Data Access/Integration（数据访问/集成）、Web、AOP（面向切面编程）、...
hello-spring:Spring学习并制作登录webApp
04-05
让我们一起探讨这个项目涉及到的核心知识点。 1. **Spring框架基础**： - **IoC（Inversion of Control，控制反转）**：Spring通过依赖注入（Dependency Injection，DI）实现IoC，使得对象间的依赖关系由Spring...
spring-framework-5.1.5.jar包
03-29
以下是关于Spring Framework 5.1.5的一些核心知识点： 1. **模块结构**： - **Core Container**：包括Spring Core、Core Container和Beans模块，是Spring的基础，提供IoC（Inversion of Control，控制反转）和DI...
JDBC基本使用（第一个jdbc程序）
dawfwafaew的博客
12-09 820
在web开发中，不可避免的地要使用数据库来存储和管理数据。为了在java语言中提供数据库访问的支持，Sun公司于1996年提供了一套访问数据的标准Java类库，即JDBC。应用程序使用JDBC访问数据库的方式如下图所示。每一门语言基本都有自己连接数据库的一套技术，列如java的就是JDBC、C#有ADO.NET等等。我们不用去纠结这些API怎么来的，我们只用知道怎么用就行了。
JAVA：Spring Session提升分布式Session管理利器
木头
08-27 2165
Spring Session提升分布式Session管理利器
JDBC项目--购物系统
weixin_51985152的博客
06-01 2123
使用Java的JDBC功能实现简易的购物系统
session和mysql_spring-session用mysql实现session共享实践
weixin_28952093的博客
01-19 367
前段时间，写了篇文章，介绍了spring-session使用redis存储实现session共享的内部机制，遇到很多人提问到jdbc的实现或者为什么只有理论没有实践？索性就实践一下jdbc方式。1.spring-session实现了使用不同存储介质保存共享的session的apispring-session实现session共享的实现有三种：jdbc：使用数据库做介质，支持多种数据，如oracle...
Spring Boot Session 会话管理示例
allway2的博客
01-28 2401
Spring Boot Session Management tutorial (2022) with Code Example | TechGeekNxt >> Jan 28, 2022 - In this article, we will discuss how to handle Spring Boot Sessionhttps://www.techgeeknext.com/spring-boot/spring-boot-session-management 实现 Spring Boot
JDBC详解
weixin_48373085的博客
01-12 3959
JDBC详解
第一个jdbc项目！
weixin_47242663的博客
04-04 83
简单的实现JDBC程序
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

喵俺第一专栏

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值