中间件作业

最新推荐文章于 2022-01-16 20:26:32 发布
最新推荐文章于 2022-01-16 20:26:32 发布
阅读量174 收藏
点赞数
分类专栏： java 文章标签： mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44715384/article/details/116374511
版权

RMI 框架 和 jdbc myql数据库使用

1. 服务器
  • 连接mysql数据库
  • rmi接口
  • 使用 gson-2.8.5.jar 和 mysql-8.0.11.jar
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DbUtil {
    private String url="jdbc:mysql://localhost:3306/zuoye?allowPublicKeyRetrieval=true&useSSL=false&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=CONVERT_TO_NULL&serverTimezone=Asia/Shanghai";
    private String dbUser="root";
    private String dbPassword="123456";
    private String dbDriver="com.mysql.cj.jdbc.Driver";
    /**
     * 连接对象
     */
    private Connection connection=null;

    public Connection getConnection(){
        try {
            Class.forName(dbDriver);
            connection=DriverManager.getConnection(url,dbUser,dbPassword);
            System.out.println("[SQL]:数据库连接成功,驱动注册成功");
        } catch (ClassNotFoundException e) {
            System.out.println("[SQL]:数据库连接失败,找不到驱动类");
            e.printStackTrace();
        } catch (SQLException throwables) {
            System.out.println("[SQL]:数据库连接失败");
            throwables.printStackTrace();
        }
        return connection;
    }

    public void closeConnection(){
        if(connection!=null){
            try {
                connection.close();
                System.out.println("[SQL]:数据库连接关闭");
            } catch (SQLException throwables) {
                System.out.println("[SQL]:数据库连接关闭失败");
                throwables.printStackTrace();
            }
        }
    }


//    /**
//     * 建立连接
//     */
//    private void initConnection(){
//        try {
//            /* 注册驱动 */
//            /*
//            方法1.注册驱动（3种方法），依赖于驱动jar包的存在，否则无法通过编译
//            DriverManager.registerDriver(new com.mysql.jdbc.Driver());
//            方法2：System.setProperties("jdbc.drivers"," com.mysql.cj.jdbc.Driver");
//            方法3：Class.forName("com.mysql.cj.jdbc.Driver");
//            */
//            Class.forName("com.mysql.cj.jdbc.Driver");
//            /* 建立连接 */
//            String jdbc="jdbc:mysql://localhost:3306/zuoye?allowPublicKeyRetrieval=true&useSSL=false&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=CONVERT_TO_NULL&serverTimezone=Asia/Shanghai";
//            conn= DriverManager.getConnection(jdbc,"jeesite","jeesite");
//            /* 创建会话 */
//            statement=conn.createStatement();
//            System.out.println("[SQL]:数据库连接成功");
//        } catch (Exception e) {
//            System.out.println("[SQL]:数据库连接失败");
//            e.printStackTrace();
//        }
//    }
}


import java.sql.Connection;

public class BaseDao<T> {
    private DbUtil dbUtil=new DbUtil();
    public Connection connection= dbUtil.getConnection();
    public void closeConnection(){
        dbUtil.closeConnection();
    }
}

import java.sql.*;
import java.util.LinkedList;
import java.util.List;

public class DBmanager extends BaseDao<StudentScore>{

    /**
     * 数据表Student中添加一条数据
     * @param studentScore
     * @return 是否添加成功
     */
    public boolean addItem(StudentScore studentScore){
        String sql="insert into Student(id,name,score) values(null,?,?)";
        try {
            PreparedStatement preparedStatement=connection.prepareStatement(sql);
            preparedStatement.setString(1,studentScore.getName());
            preparedStatement.setFloat(2,studentScore.getScore());
            return preparedStatement.executeUpdate()>0;
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return false;
    }

    /**
     * 数据表Student中删除一条数据
     * @param studentScore
     * @return 是否删除成功
     */
    public boolean delItem(StudentScore studentScore){
        String sql="delete from Student where name like ?";
        try {
            PreparedStatement preparedStatement=connection.prepareStatement(sql);
            preparedStatement.setString(1,studentScore.getName());
            return preparedStatement.executeUpdate()>0;
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return false;
    }

    /**
     * 得到数据库中全部数据列表List
     * @return LinkedList<StudentScore>
     */
    public LinkedList<StudentScore> getList(){
        LinkedList<StudentScore> resultList=new LinkedList<>();
        String sql="select * from Student";
        try {
            PreparedStatement preparedStatement=connection.prepareStatement(sql);
            ResultSet resultSet=preparedStatement.executeQuery();
            while(resultSet.next()){
                int id=resultSet.getInt(1);
                String name=resultSet.getString(2);
                float score=resultSet.getFloat(3);
                resultList.add(new StudentScore(id,name,score));
            }
        } catch (Exception throwables) {
            throwables.printStackTrace();
        }
        return resultList;
    }

    /**
     * 更新表中的一条项目Item
     * @param studentScore
     * @return 是否更新成功
     */
    public boolean updateItem(StudentScore studentScore){
        String sql="update Student set name=?, score=? where id=?";
        try {
            PreparedStatement preparedStatement=connection.prepareStatement(sql);
            preparedStatement.setString(1,studentScore.getName());
            preparedStatement.setFloat(2,studentScore.getScore());
            preparedStatement.setInt(3,studentScore.getId());
            return preparedStatement.executeUpdate()>0;
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return false;
    }

}


import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class StudentScore extends UnicastRemoteObject {
    private int id;
    private String name;
    private float score;

    public StudentScore(int id, String name, float score) throws RemoteException {
        super();
        this.id = id;
        this.name = name;
        this.score = score;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public float getScore() {
        return score;
    }

    public void setScore(float score) {
        this.score = score;
    }
}

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface DataService extends Remote {
    //public double getData() throws RemoteException;
    public String getList() throws RemoteException;
    public boolean addItem(String _name, float _score) throws RemoteException;
    public boolean delItem(String _name, float _score) throws RemoteException;
    public boolean updateItem(int id, String _name, float _score) throws RemoteException;

}


import com.google.gson.Gson;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class DataServiceImpl extends UnicastRemoteObject implements DataService {
    private DBmanager dBmanager=new DBmanager();

    public DataServiceImpl() throws RemoteException {
        super();
    }

    @Override
    public String getList() throws RemoteException {
        LinkedList<StudentScore> result=null;
        Callable<LinkedList<StudentScore>> getListTask=new Callable<LinkedList<StudentScore>>() {
            @Override
            public LinkedList<StudentScore> call() throws Exception {
                return dBmanager.getList();
            }
        };
        FutureTask<LinkedList<StudentScore>> futureTask=new FutureTask<>(getListTask);
        new Thread(futureTask).start();

        try {
            result=futureTask.get();
        } catch (Exception e) {
            e.printStackTrace();
        }
        String resultJsonString=new Gson().toJson(result);
        return resultJsonString;
    }

    @Override
    public boolean addItem(String _name, float _score) throws RemoteException {
        boolean result=false;
        StudentScore studentScore=new StudentScore(0,_name,_score);
        Callable<Boolean> addItemTask=new Callable<Boolean>() {
            @Override
            public Boolean call() throws Exception {
                return dBmanager.addItem(studentScore);
            }
        };
        FutureTask<Boolean> futureTask=new FutureTask<>(addItemTask);
        new Thread(futureTask).start();

        try {
            result=futureTask.get();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    @Override
    public boolean delItem(String _name, float _score) throws RemoteException {
        boolean result=false;
        StudentScore studentScore=new StudentScore(0,_name,_score);
        Callable<Boolean> delItemTask=new Callable<Boolean>() {
            @Override
            public Boolean call() throws Exception {
                return dBmanager.delItem(studentScore);
            }
        };
        FutureTask<Boolean> futureTask=new FutureTask<>(delItemTask);
        new Thread(futureTask).start();

        try {
            result=futureTask.get();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    @Override
    public boolean updateItem(int id, String _name, float _score) throws RemoteException {
        boolean result=false;
        StudentScore studentScore=new StudentScore(id,_name,_score);
        Callable<Boolean> updateItemTask=new Callable<Boolean>() {
            @Override
            public Boolean call() throws Exception {
                return dBmanager.updateItem(studentScore);
            }
        };
        FutureTask<Boolean> futureTask=new FutureTask<>(updateItemTask);
        new Thread(futureTask).start();

        try {
            result=futureTask.get();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
}

import java.rmi.Naming;
import java.rmi.RMISecurityManager;
import java.rmi.registry.LocateRegistry;

public class MainServer {

    public MainServer() {
    }

    public static void main(String[] args) {
        // 创建并安装安全管理器
        if (System.getSecurityManager() == null) {
            System.setSecurityManager(new RMISecurityManager());
        }

        try {
            // 创建远程对象
            DataServiceImpl ds=new DataServiceImpl();

            // 启动注册服务,如果没有这个语句，需要手工启动：开始菜单--运行--rmiregistry，默认端口1099
            LocateRegistry.createRegistry(1111);   //这里，服务端口号可任意指定

            // 远程对象绑定到服务
            Naming.rebind("//localhost:1111/ds", ds);

            System.out.println("[RMI]:服务器正在运行。。。");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}
客户端
  • rmi接口
  • 使用 gson-2.8.5.jar
import java.rmi.Remote;
import java.rmi.RemoteException;

public interface DataService extends Remote
{
    public String getList() throws RemoteException;
    public boolean addItem(String _name, float _score) throws RemoteException;
    public boolean delItem(String _name, float _score) throws RemoteException;
    public boolean updateItem(int id, String _name, float _score) throws RemoteException;
}

import com.google.gson.Gson;

import java.rmi.Naming;
import java.rmi.RMISecurityManager;
import java.util.List;
import java.util.Scanner;

public class RmiClient {
    public static void main(String[] args) {
        // 创建并安装安全管理器
        if (System.getSecurityManager() == null) {
            System.setSecurityManager(new RMISecurityManager());
        }
        Scanner scanner=new Scanner(System.in);
        try {
            DataService ds = (DataService) Naming.lookup("//localhost:1111/ds");
            System.out.println("[RMI]: 客户端已接入服务器");
            System.out.println("[TEST]: 测试开始");
            System.out.println("当前服务器中数据："+ds.getList());
            System.out.println("[TEST]: 插入一条数据");
            System.out.print("请输入学生姓名:");
            String name=scanner.next();
            System.out.println(name);
            System.out.print("请输入学生得分:");
            float score=scanner.nextFloat();
            System.out.println(score);
            ds.addItem(name,score);
            System.out.println("[TEST]: 执行插入操作");
            System.out.println("[TEST]: 查询当前数据库");
            System.out.println("当前服务器中数据："+ds.getList());
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}
小码农--向日葵
关注
专栏目录
武汉理工大学中间件平时作业
04-18
武汉理工大学中间件平时作业附源码，有需要的可以下载哦。
作业中间件项目实战
09-11 348
　　记录一下目前工作中所用到的技术点：Elastic-Job及控制台搭建、MyBatis逆向工程的使用（非插件方式）、dubbo-admin监控台的搭建、Redis搭建一主一从及哨兵模式（二）、zookeeper集群的搭建、springboot、网关、disconf---分布式配置管理平台的搭建（linux版本）、RestTemplate、dom4j+反射实现bean与xml的相互转换、...
作业调度中间件 Elastic-Job 源码解析合集
芋道源码
02-06 636
Elastic-Job-Lite 目录如下：Elastic-Job-Lite 源码分析 —— 作业配置Elastic-Job-Lite 源码分析 —— 作业初始化Elas...
大作业
qq_31724343的博客
12-31 1007
  为大作业的要求而写     目  录   第1章 概述........................................................................................ - 4 - 1.1 Hello简介.............................................................
信息安全等级保护测评作业指导书(IIS6 (2).pdf
07-11
《信息安全等级保护测评作业指导书》是对网络安全保护体系的重要指南，尤其针对IIS（Internet Information Services）后台系统，旨在确保互联网服务的安全性。该指导书详细阐述了在实施测评时的操作步骤、预期结果...
信息安全等级保护测评作业指导书(IIS6.pdf
07-11
《信息安全等级保护测评作业指导书(IIS6.pdf)》详细解读 信息安全等级保护测评是对信息系统安全防护能力的一种评估，旨在确保信息系统的安全性、可靠性和稳定性。IIS（Internet Information Services）作为微软公司...
二级等保主机安全测评作业指导书-中间件Tomcat.pdf
07-11
根据提供的文件信息，本文将详细解析“二级等保主机安全测评作业指导书-中间件Tomcat.pdf”中的关键知识点。 ### 一、二级等保主机安全测评背景 在中国的信息安全管理体系中，“等保”即“等级保护”，是中国网络...
Tomcat、Apache、Nginx、IIS、Weblogic中间件等保测评作业指导书V1.1
07-26
等保常见中间件测评指导书（供参考），也可作为中间件加固参考使用
Hadoop综合大作业
weixin_34310127的博客
05-25 84
Hadoop综合大作业 要求： 1.用Hive对爬虫大作业产生的文本文件（或者英文词频统计下载的英文长篇小说）词频统计。 启动hadoop 用hdfs创建文件夹 上传自己找的英文文章到hdfs上 启动hive，创建novels原始文档表 导入文件内容到表docs并查看 用HQL进行词频统计，结果放在表word_count里 查看统计结果 ...
向日葵远程控制
03-20
向日葵远程控制可以让电脑进行远程控制与被控制
毕业设计(九)----消息中间件
qq_36507520的博客
04-01 244
1、JMS JMS是规范(接口)---->ActiveMQ队列(实现类) JMS（Java Messaging Service）是Java平台上有关面向消息中间件的技术规范，它便于消息系统中的Java应用程序进行消息交换,并且通过提供标准的产生、发送、接收消息的接口简化企业应用的开发。 JMS本身只定义了一系列的接口规范，是一种与厂商无关的 API，用来访问消息收发系统。它类似于 JDBC(java Database Connectivity)：这里，JDBC 是可以用来访问许多不同关系数据库的 AP
常用中间件
qq_45796208的博客
10-24 3582
中间件 什么是中间件 中间件（Middleware）顾名思义是系统软件和用户软件之间连接的软件，以便于软件各部分之间的沟通，特别是应用软件对于系统软件的集中逻辑，是一种独立的系统或者服务程序，分布式应用软件借助这种软件在不同的技术之间共享资源。中间件在客户端服务器的操作系统、网络和数据库之上，管理计算机资源和网络通信。总的作用是为处于自己上层的应用软件提供运行和开发的环境，帮助用户灵活、高效的开发和集成复杂的应用软件 关于中间件，我们可以理解为：是一类能够为一种或者多种应用程序合作互通、资源共享同时还能够
java程序设计与【j2ee中间件技术】/【软件开发技术(III)】-大作业-采用MVC模式实现商品信息的查询显示（可以模糊查询）、增加和删除功能，商品表自拟，实现简单菜单操作和分页显示
zombotany的博客
01-16 4781
目录1、题目说明2、实验设计2.1 表设计2.2 工程结构3、运行界面截图与说明4、小结附录：源代码src/main/javasrc/main/java/beanGoods.javaPageBean.javasrc/main/java/daoGoodsDao.javasrc/main/java/dao/implGoodsDaoImpl.javasrc/main/java/dbDBConn.javasrc/main/java/serviceGoodsService.javasrc/main/java/serv
8大常用通讯中间件/MQ使用总结
AI论道的博客
06-14 2万+
通讯中间件（Message-oriented Middleware，简称MQ）是一种软件或硬件基础设施，支持应用程序之间或系统组件之间的发送和接收消息。MQ中间件可以简化不同系统之间的通讯，通过消息队列提供异步通信机制，允许应用程序在不直接连接的情况下进行数据交换。
浅析深究什么是中间件
hxl188的专栏
12-31 5968
本文发布于2009年10月30日 　　1. 由来 　　因为工作的原因，我从金蝶集团调入金蝶中间件公司工作以来，经常遇到一个问题就是中间件公司是个什么公司，中间件是什么？，金蝶不是做ERP的吗？怎么也做中间件？。这是我以前在金蝶集团时无法想象的问题。因为金蝶，金蝶ERP的品牌以及大众对ERP的了解，是无需我解析什么是ERP，什么是财务软件一类的问题的。 　　毕竟，中间件在实际的应用
常见的中间件有哪些
热门推荐
leizi191110211的专栏
06-06 4万+
一般本地开发的话建议使用tomcat。 linux系统建议使用jetty或apache hpptd 大型的项目就用JBOSS或webloigc 小项目，或者是个人开发tomcat 大项目或者商业项目一般采用：weblgoic/webshere 其他的还有jboss、glasshfish等 一些示例项目或者小项目常采用jetty tomcat , jboss, weblogic, web
一个完整的大作业
weixin_34279246的博客
11-02 619
1.选一个自己感兴趣的主题。 2.网络上爬取相关的数据。 3.进行文本分析，生成词云。 4.对文本分析结果解释说明。 5.写一篇完整的博客，附上源代码、数据爬取及分析结果，形成一个可展示的成果。 1我对车感兴趣 2进行数据爬取 url = "http://guangzhou.bitauto.com/" res = requests.get(url) res...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值