AI 助理
备案控制台
开发者社区 数据库 文章 正文

MySQL---数据库从入门走向大神系列(十二)-构建MVC项目（1）

2022-04-18 135
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
云数据库 RDS MySQL，集群系列 2核4GB
推荐场景：
搭建个人博客
RDS MySQL Serverless 高可用系列，价值2615元额度，1个月
简介： MySQL---数据库从入门走向大神系列(十二)-构建MVC项目

这个是对前面技术的一个小总结吧，用到的大概技术有：

MVC框架，加注解，Struts框架的思想，动态代理，线程管理对象ThreadLocal，Connection对象池，Properties文件读取，EL表达式，JSTL，JavaBean，Java访问MySQL数据库，增删改查…

其实做出来界面挺简单：

image.png

完整的项目链接：

https://github.com/chenhaoxiang/Java/tree/master/myMvcWeb2

这里只写出一些核心的类的代码：

Book.java:

package cn.hncu.domain;
/*
alter table book add constraint fk_book foreign key (studid) references stud(id);
设置studid为book的外键(fk_book)为stud的主键id
 */
public class Book {
    private Integer id;
    private String namem;
    private Double price;
    // ※一对多关系中的多方(外键字段): 在写JavaBean时，要包含对方(一方)的整个值对象类型的变量
    private Stud stud;//设置书的主人
    public Book() {
        super();
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getNamem() {
        return namem;
    }
    public void setNamem(String namem) {
        this.namem = namem;
    }
    public Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
    public Stud getStud() {
        return stud;
    }
    public void setStud(Stud stud) {
        this.stud = stud;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((id == null) ? 0 : id.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Book other = (Book) obj;
        if (id == null) {
            if (other.id != null)
                return false;
        } else if (!id.equals(other.id))
            return false;
        return true;
    }
}

Stud.java

package cn.hncu.domain;
import java.util.ArrayList;
import java.util.List;
public class Stud {
    private String id;
    private String name;
    //※一对多中的一方: 添加一个集合(用set也行)以表示该关系
    private List<Book > books = new ArrayList<Book>();
    public Stud() {
        super();
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public List<Book> getBooks() {
        return books;
    }
    public void setBooks(List<Book> books) {
        this.books = books;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((id == null) ? 0 : id.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Stud other = (Stud) obj;
        if (id == null) {
            if (other.id != null)
                return false;
        } else if (!id.equals(other.id))
            return false;
        return true;
    }
    //注意,如果要添加toString()方法，注意一对多关系中的信息输出嵌套
}

TxProxy.java:

package cn.hncu.pubs.tx;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import cn.hncu.pubs.ConnsUtil;
public class TxProxy implements InvocationHandler{
    private Object srcObj;
    public TxProxy(Object srcObj) {
        this.srcObj = srcObj;
    }
    /* 版本1
    public static Object getProxy(Object srcObj){
        Object proxiedObj = Proxy.newProxyInstance(TxProxy.class.getClassLoader(),
                            srcObj.getClass().getInterfaces(),
                            new TxProxy(srcObj));
        return proxiedObj;
    }
    */
    /* 版本2
    public static<T> T getProxy(Object srcObj, Class<T> cls){
        Object proxiedObj = Proxy.newProxyInstance(TxProxy.class.getClassLoader(),
                            srcObj.getClass().getInterfaces(),
                            new TxProxy(srcObj));
        return (T)proxiedObj;
    }
    */
    /* 版本3
    public static<T> T getProxy(Class<T> cls){
        Object srcObj = null;
        try {
            srcObj = cls.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        Object proxiedObj = Proxy.newProxyInstance(TxProxy.class.getClassLoader(),
                            srcObj.getClass().getInterfaces(),
                            new TxProxy(srcObj));
        return (T)proxiedObj;
    }
    */
    //版本4
    public static<T> T getProxy(T srcObj){
        Object proxiedObj = Proxy.newProxyInstance(TxProxy.class.getClassLoader(),
                            srcObj.getClass().getInterfaces(),
                            new TxProxy(srcObj));
        return (T)proxiedObj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        //判断method方法是不是添加了注解
        if(method.isAnnotationPresent(Transaction.class)){
            Connection con=null;
            Object returnValue =null;
            try {
                con = ConnsUtil.getConnection();
                con.setAutoCommit(false);
                System.out.println("在动态代理中开启一个事务....");
                returnValue = method.invoke(srcObj, args);
                con.commit();
                System.out.println("在动态代理中提交一个事务....");
            } catch (Exception e) {
                con.rollback();
                System.out.println("在动态代理中回滚一个事务....");
            }finally{
                if(con!=null){
                    try {
                        con.setAutoCommit(true);
                        con.close();
                    } catch (Exception e) {
                        throw new RuntimeException("数据库连接关闭失败", e);
                    }
                }
            }
            return returnValue;
        }else{//没有添加注解,直接放行
            return method.invoke(srcObj, args);
        }
    }
}

Transaction.java:注解

package cn.hncu.pubs.tx;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(value=ElementType.METHOD)
public @interface Transaction {
}

BaseServlet.java:

package cn.hncu.pubs;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
 * @author 陈浩翔
 *
 * 2016-8-15
 */
public abstract class BaseServlet extends HttpServlet{
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        doPost(req, resp);
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");
        String cmd = req.getParameter("cmd");
        if(cmd==null){
            cmd="execute";
        }
        try {
            System.out.println("this:"+this);
            //下面这句不能访问私有方法
            //Method m = this.getClass().getMethod(cmd, HttpServletRequest.class,HttpServletResponse.class );
            //如果要用类反射实现访问类的私有方法，则需要这2步,这样子类的方法就不用设置成public了。
            //1获得私有方法  
            Method m = this.getClass().getDeclaredMethod(cmd, HttpServletRequest.class,HttpServletResponse.class );
            //2设置私有方法可以被访问 
            m.setAccessible(true);
            m.invoke(this, req,resp);//这里的this是子类对象，谁调用这里的，这个this就是谁    
            //下面这几句是给大家启发Struts框架的思想
//          String str =(String) m.invoke(this, request,response);
//          String resPage = "";//从配置struts.xml文件中读取str所对应的结果页面的地址
//          request.getRequestDispatcher(resPage).forward(request,response);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
    //如果没有参数cmd为null，转向的界面，由子类自己实现
    public abstract void execute(HttpServletRequest request, HttpServletResponse response);
}

ConnsUtil.java

package cn.hncu.pubs;
import java.io.IOException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
public class ConnsUtil {
    private static List<Connection> pool = new ArrayList<Connection>();
    private static final int NUM = 3;
    private static ThreadLocal<Connection> t = new ThreadLocal<Connection>();
    static{
        try {
            //读取配置文件
            Properties p = new Properties();
            p.load(ConnsUtil.class.getClassLoader().getResourceAsStream("jdbc.properties"));
            String driver = p.getProperty("driver");
            String url = p.getProperty("url");
            String user = p.getProperty("username");
            String password = p.getProperty("password");
            Class.forName(driver);
            for(int i=0;i<NUM;i++){
                final Connection conn = DriverManager.getConnection(url, user, password);
                //System.out.println(conn.getClass().getClassLoader());//AppClassLoader
                //使用动态代理,代理conn对象，实现对close方法的拦截
                Object obj = Proxy.newProxyInstance(ConnsUtil.class.getClassLoader(),
                            new Class[]{Connection.class},
                            new InvocationHandler() {
                            @Override
                            public Object invoke(Object proxy, Method method, Object[] args)
                            throws Throwable {
                                //拦截close方法
                                if(method.getName().equalsIgnoreCase("close") &&(args==null||args.length==0) ){
                                    pool.add((Connection)proxy);
                                    //proxy为代理后的对象
                                    t.set(null);//把存储在本地线程管理类中的当前线程对应的对象设为空
                                    return null;
                                }
                                //conn为被代理的对象
                                return method.invoke(conn, args);
                            }
                        });
                pool.add( (Connection)obj);//把代理后的conn对象即obj加入池中
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public static synchronized Connection getConnection() throws InterruptedException{
        //从本地线程管理对象t中拿
        Connection con = t.get();
        if(con==null){
            if(pool.size()<=0){
                Thread.sleep(50);
                return getConnection();
            }
            con=pool.remove(0);
            //放入到t中
            t.set(con);
        }
        return con;
    }
}

StudServlet.java:

package cn.hncu.stud;
import java.io.IOException;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import cn.hncu.domain.Book;
import cn.hncu.domain.Stud;
import cn.hncu.pubs.BaseServlet;
import cn.hncu.pubs.tx.TxProxy;
import cn.hncu.stud.service.IStudService;
import cn.hncu.stud.service.StudService;
public class StudServlet extends BaseServlet {
    //版本1
    //private IStudService service = (IStudService) TxProxy.getProxy(new StudService());
    //版本2
    //private IStudService service = TxProxy.getProxy(new StudService(),IStudService.class);
    //版本3
    //private IStudService service = TxProxy.getProxy(StudService.class);//用实现类的class
    //版本4
    private IStudService service = TxProxy.getProxy(new StudService());//用实现类的class
    private void save(HttpServletRequest request, HttpServletResponse response) throws InterruptedException, ServletException, IOException {
        //收集并封装stud
        String name = request.getParameter("name");
        if(name==null||name.trim().length()<=0){
            response.sendRedirect("index.jsp");//重定向
            return ;
        }
        Stud stud = new Stud();
        stud.setName(name);
        //收集并封装所有book
        String bookNames[] = request.getParameterValues("bookname");//获取多个值
        String prices[] = request.getParameterValues("price");
        if(bookNames!=null){
            for(int i=0;i<bookNames.length;i++){
                Book book = new Book();
                if(bookNames[i]==null || bookNames[i].trim().length()<=0){
                    continue;
                }
                book.setNamem(bookNames[i]);
                if(prices[i]!=null && prices[i].trim().length()!=0 ){
                    Double price=0.0;
                    try {
                        price = Double.parseDouble(prices[i]);
                    } catch (NumberFormatException e) {
                        price=0.0;
                    }
                    book.setPrice(price);
                }
                book.setStud(stud);
                //继续封装stud----为stud中的books属性赋值--一方中的集合
                stud.getBooks().add(book);
            }
        }
        try {
            service.save(stud);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    private void query(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        List<Map<String, String>> studs = service.query();
        request.setAttribute("studs", studs);
        request.getRequestDispatcher("/jsps/show.jsp").forward(request, response);
    }
    @Override
    public void execute(HttpServletRequest request, HttpServletResponse response) {
        System.out.println("调用默认业务处理方法....");
    }
}
文章标签：
云数据库 RDS MySQL 版
Java
前端开发
关系型数据库
MySQL
数据库
关键词：
云数据库 RDS MySQL 版数据库
mysql数据库
数据库mysql
入门mvc
mvc项目
相关实践学习
如何在云端创建MySQL数据库
开始实验后，系统会自动创建一台自建MySQL的 源数据库 ECS 实例和一台 目标数据库 RDS。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心，利用清洁计算为万物互联的新世界提供源源不断的能源动力，目前开服的区域包括中国（华北、华东、华南、香港）、新加坡、美国（美东、美西）、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程，来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品：云服务器ECS 云服务器 ECS（Elastic Compute Service）是一种弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率，使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
谙忆
目录
相关文章
刘大猫.
|
13天前
|
分布式计算 关系型数据库 MySQL
SpringBoot项目中mysql字段映射使用JSONObject和JSONArray类型
SpringBoot项目中mysql字段映射使用JSONObject和JSONArray类型 图像处理 光通信 分布式计算 算法语言 信息技术 计算机应用
刘大猫.
36 8
路卿老师
|
10天前
|
SQL 关系型数据库 MySQL
12 PHP配置数据库MySQL
路老师分享了PHP操作MySQL数据库的方法，包括安装并连接MySQL服务器、选择数据库、执行SQL语句（如插入、更新、删除和查询），以及将结果集返回到数组。通过具体示例代码，详细介绍了每一步的操作流程，帮助读者快速入门PHP与MySQL的交互。
路卿老师
26 1
听风de歌
|
12天前
|
SQL 关系型数据库 MySQL
go语言数据库中mysql驱动安装
【11月更文挑战第2天】
听风de歌
29 4
html的七十二变
|
17天前
|
存储 前端开发 数据可视化
在实际项目中，如何选择使用 Flux 架构或传统的 MVC 架构
在实际项目中选择使用Flux架构或传统MVC架构时，需考虑项目复杂度、团队熟悉度和性能需求。Flux适合大型、高并发应用，MVC则适用于中小型、逻辑简单的项目。
html的七十二变
53 6
土木林森
|
19天前
|
监控 关系型数据库 MySQL
数据库优化：MySQL索引策略与查询性能调优实战
【10月更文挑战第27天】本文深入探讨了MySQL的索引策略和查询性能调优技巧。通过介绍B-Tree索引、哈希索引和全文索引等不同类型，以及如何创建和维护索引，结合实战案例分析查询执行计划，帮助读者掌握提升查询性能的方法。定期优化索引和调整查询语句是提高数据库性能的关键。
土木林森
90 1
众所周知
|
21天前
|
关系型数据库 MySQL Linux
在 CentOS 7 中通过编译源码方式安装 MySQL 数据库的详细步骤，包括准备工作、下载源码、编译安装、配置 MySQL 服务、登录设置等。
本文介绍了在 CentOS 7 中通过编译源码方式安装 MySQL 数据库的详细步骤，包括准备工作、下载源码、编译安装、配置 MySQL 服务、登录设置等。同时，文章还对比了编译源码安装与使用 RPM 包安装的优缺点，帮助读者根据需求选择最合适的方法。通过具体案例，展示了编译源码安装的灵活性和定制性。
众所周知
64 2
众所周知
|
24天前
|
存储 关系型数据库 MySQL
MySQL vs. PostgreSQL：选择适合你的开源数据库
在众多开源数据库中，MySQL和PostgreSQL无疑是最受欢迎的两个。它们都有着强大的功能、广泛的社区支持和丰富的生态系统。然而，它们在设计理念、性能特点、功能特性等方面存在着显著的差异。本文将从这三个方面对MySQL和PostgreSQL进行比较，以帮助您选择更适合您需求的开源数据库。
众所周知
94 4
快乐就是哈哈哈
|
29天前
|
SQL JavaScript 关系型数据库
node博客小项目：接口开发、连接mysql数据库
【10月更文挑战第14天】node博客小项目：接口开发、连接mysql数据库
快乐就是哈哈哈
30 2
小陈运维
|
7天前
|
运维 关系型数据库 MySQL
安装MySQL8数据库
本文介绍了MySQL的不同版本及其特点，并详细描述了如何通过Yum源安装MySQL 8.4社区版，包括配置Yum源、安装MySQL、启动服务、设置开机自启动、修改root用户密码以及设置远程登录等步骤。最后还提供了测试连接的方法。适用于初学者和运维人员。
小陈运维
57 0
代码bug生产队
|
30天前
|
存储 关系型数据库 MySQL
如何在MySQL中创建数据库？
【10月更文挑战第16天】如何在MySQL中创建数据库？
代码bug生产队
45 1

热门文章

最新文章

  • 1
    SQLServer数据库日志清理 清除sqlserver2005日志 - sk
  • 2
    数据库被注入daxia123原因及解决办法
  • 3
    ChatGPT 引爆向量数据库赛道
  • 4
    创建逻辑stand by数据库
  • 5
    官宣，首届阿里云NoSQL数据库峰会来袭！火速收藏
  • 6
    sql语句查询数据库表结构信息
  • 7
    Android 数据库ORM框架GreenDao学习心得及使用总结<二>
  • 8
    SQLite数据库版本升级的管理实现
  • 9
    《你不可不知的关系数据库理论》——第1章 数据库基本概念
  • 10
    归档问题导致的数据库无法启动
  • 1
    我以为我对Spring MVC很了解，直到我遇到了...
    128
  • 2
    Spring Boot与Spring MVC的区别和联系
    84
  • 3
    深入理解MVC设计模式：构建高效Web应用程序的基石
    159
  • 4
    Spring MVC中使用ModelAndView传递数据
    42
  • 5
    Spring-MVC的数据响应-19
    34
  • 6
    技术经验分享：ExtJS4MVC架构讲解
    34
  • 7
    Spring-MVC的注解扫描-spring17
    21
  • 8
    spring mvc 请求与响应
    28
  • 9
    spring mvc Rest风格
    40
  • 10
    理解最常用的MVC分层模型及其变种
    358

    • 相关课程

    更多
  • 数据库的前世今生
  • 数据库核心概念
  • 从传统数据库到云数据库演进
  • 数据库常见问题排查
  • 数据库及SQL/MySQL基础
  • 高校精品课-西安交通大学 -数据库理论与技术

    • 相关电子书

    更多
  • DTCC 2022大会集锦《云原生一站式数据库技术与实践》
  • 阿里云瑶池数据库精要2022版
  • 2022 DTCC-阿里云一站式数据库上云最佳实践

    • 相关实验场景

    更多
  • 数据库实验室挑战任务-高级任务
  • 数据库实验室挑战任务-中级任务
  • 数据库实验室挑战任务-初级任务
  • 阿里云数据库产品实验室
  • MongoDB数据库入门
  • 使用DAS实现数据库自动扩容和回缩

    • 推荐镜像

    更多
  • mysql
  • mariadb
  • postgresql
    • 下一篇
    无影云桌面