精华内容
下载资源
问答
  • 大神都会点开这个帖子的,所以我就开门见山了 1. java写服务器端如何返回手机安卓用户端能接受的数据形式? 2. 如何处理手机端返回的数据 3. 如何对接起来
  • java实现读写服务器文件

    万次阅读 2018-10-17 13:06:33
    这个主要实现的Java远程访问服务器的读写文件操作,自动登录读写文件 pom.xml中要配置 <dependency> <groupId>ch.ethz.ganymed</groupId> <artifactId>ganymed-ssh2</artifactId&...

    这个主要实现的Java远程访问服务器的读写文件操作,自动登录读写文件

    pom.xml中要配置

        <dependency>
            <groupId>ch.ethz.ganymed</groupId>
            <artifactId>ganymed-ssh2</artifactId>
            <version>build210</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.jcraft/jsch -->
        <dependency>
            <groupId>com.jcraft</groupId>
            <artifactId>jsch</artifactId>
            <version>0.1.54</version>
        </dependency>
    

    文件loginServer主要类中有个getProperties这个方法是配置服务器的地址信息的,需要先配置地址信息然后调用登录去做登录的操作LoginServer.login(LoginServer.getProperties(Config.Alertkey1 +“。json”),false );

    核心代码  LoginServer主要的工具类 

    package com.maxd.upload;
    import java.io.*;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Properties;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    import ch.ethz.ssh2.Connection;
    import ch.ethz.ssh2.SCPClient;
    import ch.ethz.ssh2.StreamGobbler;
    import com.jcraft.jsch.JSch;
    import com.jcraft.jsch.Session;
    import com.maxd.utils.Config;
    
    public class LoginServer {
        /**
         * @param ip              服务器IP
         * @param user            服务器用户名
         * @param pwd             服务器密码
         * @param port            端口
         * @param privateKeyPath  可为空
         * @param passphrase      可为空
         * @param sourcePath      本地文件路径
         * @param destinationPath 上传路径
         */
        private static void downLoadFile(String ip, String user, String pwd, String port, String privateKeyPath, String passphrase, String sourcePath, String destinationPath) {
            doWrite(ip, user, pwd, port, privateKeyPath, passphrase, sourcePath, destinationPath);
        }
    
        /**
         * 设置配置
         * @param fileName
         * @return
         */
        public static Properties getProperties(String fileName) {
            Properties properties = new Properties();
            properties.setProperty("ip", Config.hostname);
            properties.setProperty("user", Config.username);
            properties.setProperty("pwd", Config.password);
            properties.setProperty("port", String.valueOf(Config.port));
            properties.setProperty("sourcePath", Config.sourcePath + fileName);
            properties.setProperty("destinationPath", Config.destinationPath);
            return properties;
        }
    
        /**
         * @param properties
         * @param isRead     true表示读取 false表示写入
         */
        public static void login(Properties properties, boolean isRead) {
            String ip = properties.getProperty("ip");
            String user = properties.getProperty("user");
            String pwd = properties.getProperty("pwd");
            String port = properties.getProperty("port");
            String privateKeyPath = properties.getProperty("privateKeyPath");
            String passphrase = properties.getProperty("passphrase");
            String sourcePath = properties.getProperty("sourcePath");
            String destinationPath = properties.getProperty("destinationPath");
            if (!isRead) {
                //写入本地文件到远程服务器
                doWrite(ip, user, pwd, port, privateKeyPath, passphrase, sourcePath, destinationPath);
            } else {
                //读取远程文件到本地
                readConnect();
            }
        }
    
        /**
         * @throws IOException
         * @description 读文件
         */
        public static String readTxtFile(File fileName) throws IOException {
            String result = null;
            FileReader fileReader = null;
            BufferedReader bufferedReader = null;
            fileReader = new FileReader(fileName);
            InputStreamReader isr = new InputStreamReader(new FileInputStream(fileName), "UTF-8");
            BufferedReader bufferedReader1 = new BufferedReader(isr);
            String read = null;
            int count = 0;
            while ((read = bufferedReader1.readLine()) != null) {
                result = read + "\r\n";
                count++;
            }
            if (bufferedReader != null) {
                bufferedReader.close();
            }
            if (fileReader != null) {
                fileReader.close();
            }
            return result;
        }
    
        /**
         * @throws UnsupportedEncodingException
         * @throws IOException
         * @description 写文件
         */
        public static boolean writeTxtFile(String content, File fileName) throws UnsupportedEncodingException, IOException {
            FileOutputStream o = null;
            o = new FileOutputStream(fileName);
            o.write(content.getBytes("UTF-8"));
            o.close();
            return true;
        }
    
        private static void doWrite(String ip, String user, String pwd, String port, String privateKeyPath, String passphrase, String sourcePath, String destinationPath) {
            if (ip != null && !ip.equals("") && user != null && !user.equals("") && port != null && !port.equals("") && sourcePath != null && !sourcePath.equals("") && destinationPath != null && !destinationPath.equals("")) {
                if (privateKeyPath != null && !privateKeyPath.equals("")) {
                    sshSftp2(ip, user, Integer.parseInt(port), privateKeyPath,
                            passphrase, sourcePath, destinationPath);
                } else if (pwd != null && !pwd.equals("")) {
                    sshSftp(ip, user, pwd, Integer.parseInt(port), sourcePath,
                            destinationPath);
                } else {
                    Console console = System.console();
                    System.out.print("Enter password:");
                    char[] readPassword = console.readPassword();
                    sshSftp(ip, user, new String(readPassword),
                            Integer.parseInt(port), sourcePath, destinationPath);
                }
            } else {
                System.out.println("请先设置配置文件");
            }
        }
    
        /**
         * 密码方式登录
         *
         * @param ip
         * @param user
         * @param psw
         * @param port
         * @param sPath
         * @param dPath
         */
        private static void sshSftp(String ip, String user, String psw, int port,
                                    String sPath, String dPath) {
            System.out.println("password login");
            Session session = null;
    
            JSch jsch = new JSch();
            try {
                if (port <= 0) {
                    // 连接服务器,采用默认端口
                    session = jsch.getSession(user, ip);
                } else {
                    // 采用指定的端口连接服务器
                    session = jsch.getSession(user, ip, port);
                }
                // 如果服务器连接不上,则抛出异常
                if (session == null) {
                    throw new Exception("session is null");
                }
                // 设置登陆主机的密码
                session.setPassword(psw);// 设置密码
                // 设置第一次登陆的时候提示,可选值:(ask | yes | no)
                session.setConfig("StrictHostKeyChecking", "no");
                // 设置登陆超时时间
                session.connect(300000);
                UpLoadFile.upLoadFile(session, sPath, dPath);
                //DownLoadFile.downLoadFile(session, sPath, dPath);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("success");
        }
    
        /**
         * 密匙方式登录
         *
         * @param ip
         * @param user
         * @param port
         * @param privateKey
         * @param passphrase
         * @param sPath
         * @param dPath
         */
        private static void sshSftp2(String ip, String user, int port,
                                     String privateKey, String passphrase, String sPath, String dPath) {
            System.out.println("privateKey login");
            Session session = null;
            JSch jsch = new JSch();
            try {
                // 设置密钥和密码
                // 支持密钥的方式登陆,只需在jsch.getSession之前设置一下密钥的相关信息就可以了
                if (privateKey != null && !"".equals(privateKey)) {
                    if (passphrase != null && "".equals(passphrase)) {
                        // 设置带口令的密钥
                        jsch.addIdentity(privateKey, passphrase);
                    } else {
                        // 设置不带口令的密钥
                        jsch.addIdentity(privateKey);
                    }
                }
                if (port <= 0) {
                    // 连接服务器,采用默认端口
                    session = jsch.getSession(user, ip);
                } else {
                    // 采用指定的端口连接服务器
                    session = jsch.getSession(user, ip, port);
                }
                // 如果服务器连接不上,则抛出异常
                if (session == null) {
                    throw new Exception("session is null");
                }
                // 设置第一次登陆的时候提示,可选值:(ask | yes | no)
                session.setConfig("StrictHostKeyChecking", "no");
                // 设置登陆超时时间
                session.connect(300000);
                UpLoadFile.upLoadFile(session, sPath, dPath);
                System.out.println("success");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 读取远程文件到本地
         */
        private static void readConnect() {
            Connection conn = new Connection(Config.hostname, Config.port);
            ch.ethz.ssh2.Session ssh = null;
            try {
                //连接到主机
                conn.connect();
                //使用用户名和密码校验
                boolean isconn = conn.authenticateWithPassword(Config.username, Config.password);
                if (!isconn) {
                    System.out.println("用户名称或者是密码不正确");
                } else {
                    System.out.println("已经连接OK");
                    File folder = new File(Config.writePath);
                    if (!folder.exists()) {
                        folder.mkdir();
                    }
                    SCPClient clt = conn.createSCPClient();
                    ssh = conn.openSession();
                    ssh.execCommand("find /app/s3-configuration/ -name '*.json'");
                    InputStream is = new StreamGobbler(ssh.getStdout());
                    BufferedReader brs = new BufferedReader(new InputStreamReader(is));
                    while (true) {
                        String line = brs.readLine();
                        if (line == null) {
                            break;
                        }
                        clt.get(line, Config.writePath);
                        List<File> lf = new ArrayList<File>();
                        lf = getFileList(new File(Config.writePath), "json");
                        for (File f : lf) {
                            /*System.out.println(f.getPath());*/
                            String path = f.getPath();
                            File file = new File(path);
                            try {
                                FileReader fr = new FileReader(file);
                                BufferedReader br = new BufferedReader(fr);
                                String s = null;
                                Pattern p = Pattern.compile(".*?error.*?");
                                while ((s = br.readLine()) != null) {
                                    Matcher m = p.matcher(s);
                                    if (m.find()) {
                                        /*System.out.println(m.matches());*/
                                        System.out.println(line);
                                        System.out.println("find error!");
                                    }/*else{
                                        System.out.println("no error");
                                    }   */
                                }
    
                                br.close();
                            } catch (FileNotFoundException e) {
                                System.err.println("file not found");
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
    
                        }
                        System.out.println("文件输出成功,请在" + Config.writePath + "中查看");
    
                    }
    
                }
            } catch (IOException e) {
                System.out.println(e.getMessage());
                e.printStackTrace();
            } finally {
                //连接的Session和Connection对象都需要关闭
                if (ssh != null) {
                    ssh.close();
                }
                if (conn != null) {
                    conn.close();
                }
            }
        }
    
        private static List<File> getFileList(File fileDir, String fileType) {
            List<File> lfile = new ArrayList<File>();
            File[] fs = fileDir.listFiles();
            for (File f : fs) {
                if (f.isFile()) {
                    if (fileType.equals(f.getName().substring(f.getName().lastIndexOf(".") + 1, f.getName().length())))
                        lfile.add(f);
                } else {
                    List<File> ftemps = getFileList(f, fileType);
                    lfile.addAll(ftemps);
                }
            }
            return lfile;
        }
    }
    

    文件下载地址

    收费下载地址:

    https://download.csdn.net/download/weixin_39706415/10760178

    免费下载方式:

    关注微信公众号【码兄】回复【1234】获取

    展开全文
  • 自己动手——快速搭建Java应用服务器

    万次阅读 多人点赞 2017-05-08 11:33:17
    这套帖子的目的,是在自己学会、实现并熟练掌握之后,想帮助下面将会提到的这样一群正在学习Android的新手(虽然我自己也是新手),通过自己的经验传递出去,让他们少走一点弯路,节省大量用在查询和翻阅资料的...


    Motivation

    我写这系列博文的目的,是在自己学会、实现并熟练掌握之后,想帮助正在学习的人门,通过将自己的经验传递出去,让你们少走一点弯路,节省大量用在查询和翻阅资料上的时间。

    我在学习编写自己的服务器程序的时候遇到过以下的问题:
    1.我需要准备什么?
    2.我该选择哪一套实现方案?

    这些问题的搜索和查证都需要占用大量的时间,以至于初学者们手头的项目可能长达几个月没有进展,而我会一一为大家解决这些问题,你只需要花费看这一篇博文的时间。


    好了,言归正传:

    一、什么是前后端分离?

    即前后端代码分别开发并独立部署。
    前端: 实现静态/动态页面,必要时向后端发起http请求,并根据后端的响应结果对页面进行刷新或跳转。
    后端: 后端不再负责处理对静态资源的请求,仅提供请求接口,在收到前端发来的请求时给与响应。


    二、我需要准备什么?

    硬件要求:

    一台开发机和一台云服务器,当前各大云服务提供商的云服务器产品十分便宜,甚至有大学生优惠。每月不超过10块,所以推荐租一台Linux系统的云服务器,省去了很多麻烦(后续会有帖子介绍流程)。

    软件要求:

    安装JDK并配置完环境变量 (本系列博文统一采用JDK 1.8)
    还有一些软件是需要用到的,到了具体的章节我们再引入。

    知识储备要求:

    1.基础Java知识和基础Java编程能力:

    也不需要对Java有多么深的理解,但是Java面向对象的三大要素——封装、继承、多态——至少要理解得清清楚楚!如果连静态方法和非静态方法都搞不清楚,那还怎么写程序?!

    2.计算机网络基础知识:

    对以下概念有较清晰的认识即可:
    ①内网与外网;②局域网;③IP地址;④端口号;⑤Http请求;

    3.数据库相关知识:

    时间充分的话还是强烈建议系统学习,因为没有学好可能以后写出的查询语句效率低下还不知道怎么优化。时间紧迫的话,会常用的建库、建表、创建字段、增删改查即可。


    三、我该选择哪一套方案?

    在具有了一台云服务器这一硬件条件后,我们的服务器仅仅有了一个容器,真正能让它工作起来的是一套软件相关的东西。
    在本系列博文中,我们用:MySQL + Java Web + Tomcat来实现我们的服务器。

    其中:
    ①MySQL是开源的数据库软件;
    ②Java Web是遵循Java语言风格的服务器应用程序组件(即客户端发来的请求的应答者);
    ③Tomcat是开源的服务器软件(作为Java Web应用程序的容器)。


    四、开发部署流程

    1. 在Windows、Mac等有UI界面的机器上做开发。
    2. 开发完成后,将工程打包成.jar或.war文件,称为jar包或war包。
    3. 将jar包或war包上传到服务器上进行解包——称作“部署”。

    由于开发时需要做一定的测试,每次测试都部署一遍会消耗大量时间和精力。因此,开发机上也需要装MySQL数据库和Tomcat服务器容器。


    五、客户端发送Http请求和接收到应答的流程

    我来描述一下从各客户端发出一趟请求到收到应答的过程(没图,但是我会说到各种图往往笼统和忽略的部分):

    1.客户端向指定IP地址(或域名)的服务器发出一条Http请求(例如包含账号和密码的登录请求);

    2.服务器容器Tomcat收到Http请求,寻找相应Java Web编写的服务器应用程序,把请求分派给它来处理;

    3.Java Web编写的服务器应用程序找到处理请求相应的Servlet(Java Web项目的一部分,后面会讲)实例,把请求分配给它处理;

    4.Servlet根据请求来执行相应的操作(如调用数据库然后验证登录是否成功),将结果添加到应答中,发回客户端;

    5.客户端接收到应答,从应答中解析出结果(如登录是否成功),然后根据结果执行相应的逻辑(如跳转页面或提示账号密码不正确等)。


    六、基础实现

    实现的部分,我分到了多篇博文中去讲各个部分的实现及其衔接:

    1. 构建开发环境——安装集成开发工具包XAMPP

    2. 调试入门——如何快速定位并修复Bug

    3. Web开发入门——创建Java Web工程

    4. 部署和测试


    七、初级进阶

    到这里,我们实现了基础的请求/响应流程,但要实现完善的后端服务,还需要学习一些进阶知识:

    1. 数据管理——创建并通过Java连接MySQL数据库

    2. 数据传输——JSONObject与JSONArray

    3. Servlet请求调度器——DispatcherServlet

    4. Q&A


    八、中级进阶

    学习了前面的这些知识,并做了一些实践,实际上学习成本不高,但是实现成本比较高。这些都是10多年前开发者们实现Java Web后端程序的方法和过程。

    看到这里你可能有点失落:“学了半天,居然是10多年前的老方法”。我自然会讲现在的新技术,但前面的过程也是必不可少的,理由如下:

    • 一步一步进阶学习的过程比较平稳,不至于被新技术的复杂知识体系吓住。
    • 老技术学习成本低,但实现成本高,适合快速学习。
    • 进阶学习的过程可以使我们知道,老技术为何被放弃,新技术的优越性有哪些。

    总之,技术的革新都是为了不断地解放生产力,让我们用更少的代码实现更多的功能,热爱学习和实现的你,耐心地往下看吧。

    1. 依赖管理进阶——Maven学习笔记

    2. 初识框架——Spring学习笔记


    九、高级进阶

    这个部分,我是想写SpringBoot的,记得当时进阶学习也就用了两天,因此从Spring Framework进阶到SpringBoot是很快的。Spring Framework中我们扔掉了web.xml,Spring Boot中我们连配置文件也不要了。写后端服务更加便捷。

    敬请期待
    ——2020.11.13


    更新日志

    这篇综述和索引的博文我就写到这了,去写几个分帖了,写出来之后我会第一时间在这里挂上链接,敬请期待。
    我的这一系列博文应该会在两周左右全部写完,如果是有紧急的问题需要帮助的朋友,直接回帖或者给我发邮件,在时间充足和我会的情况下帮你解决。
    ——2017.05.08

    实在是有些忙,今天忙里偷闲一天,写完了内网穿透的博文,已经在上面挂上了链接。我仔细想了一下,上面第二步可能需要三篇博文分别来讲服务器、数据库集成开发工具包的介绍,Java Web的编写和Tomcat的使用,之前吹牛说两周写完可能做不到了
    ——2017.05.12

    今早写了服务器、数据库集成开发工具包这篇文章,已经在上面挂上了链接。
    ——2017.05.13

    今天开始写Java Web的编写,写了之后才发现,这个确实挺麻烦的,各种细节需要各种截图,已经在上面挂上了链接,没写完,可以先看看前面的准备部分。
    ——2017.05.15

    今晚终于抽空写完了Java Web的编写, 诸君可以照葫芦画瓢,写自己的服务器程序了,博文有点长,进下心来慢慢看吧,绝对有收获!今天写着写着,又想到我好像没有规划MySQL建数据库的部分,就在索引中添上了。
    ——2017.05.17

    今天写完了MySQL数据库的建立,已经在上面挂上了链接。
    ——2017.05.18

    今天把Tomcat的一些使用方法写完了,写着写着突然忘了本来准备的内容了,略尴尬。
    ——2017.05.19

    今天终于把原计划的这最后一篇文章写完了,已经在上面挂上了链接。 原本计划两周写完的,这都拖了将近一个多月了。但是最近真的很忙,没办法。

    近期如果有空,我会写一篇番外文章,讲一点关于JSONObject和JSONArray的东西,应该会比较短,但是会很有用,尽请期待吧!
    ——2017.07.01

    根据各位开发者看完这一系列博文之后在开发过程中的反馈,今天对《内网穿透》、《Tomcat》和《Java Web》等三帖做了一些更新。
    ——2018.03.11

    时隔将近一年,我终于把承诺的JSONObject和JSONArray的部分写出来了,作为进阶使用的番外部分,已在上面挂上了链接。

    另外,今天写的尽兴的时候,想起了Servlet分配器这个东西,作为进阶内容的话还是很有意义与价值的。这次不会再跳票那么长时间了,一两天内完成,尽情期待!
    ——2018.04.12

    Servlet请求分派器的博文已经写完了,在上面挂上了链接。
    ——2018.04.14

    鉴于做整体的系统测试的时候,很难定位Bug出在了客户端还是服务端,我将《Tomcat的一些使用方法》这篇博文改名为《服务器端的一些测试方法》,并在里面添加了分享3。根据分享3,大家可以先写服务端,不写客户端,服务端测试正确了再开始写客户端,这样做的好处就是,我们可以更加精准的做到Bug定位了。
    ——2018.05.05

    今天做了一个重要的调整,即《MySQL》和《JavaWeb》两篇博文的次序,如果还是按我写它们时的顺序放在索引里,会造成你们逻辑的颠倒,因此,调了过来。
    ——2018.05.11

    根据近期自己在开发中的亲身经历和大家的反馈,写了一篇收集由PC和真实服务器环境的差异造成的Bug的博文,不光收集问题,也写了这些问题的解决方法。 大家在服务端出现Bug的时候可以点进去看看,有可能就对号入座,解决问题了,同时也鼓励各位开发者同仁,贡献出你们在开发过程中遇到的,各种各样的问题及其解决方案。
    ——2018.05.14

    为了便于索引和阅读,准备在所有的博文上加上目录,尤其是篇幅比较长的博文。
    ——2018.12.27

    近期发现有不止一个人问,non-static method 'XXX' can not be referenced from a static context这个异常怎么解决,怎样把XXX函数改成静态的?这就相当过分了。我也反省了一下是不是我这个教程写得太傻瓜式操作了。最后还是觉得,好东西也要看谁拿着。我再清清楚楚地声明一下:我这篇博文不是针对一点基础知识都没有的小白的,缺什么基础知识就去学完再来搞实践!!!
    ——2019.04.16

    今天对博文的内容和格式做了部分修改,同时根据近期开发和部署上遇到的一些问题,写了一篇新的博文用于记录软件版本差异造成的异常及其解决方案。
    ——2019.05.08

    我时常觉得自己比较后知后觉,却又很庆幸,虽然晚一些,但最终还是“觉”了。直到不久前才学到了所谓“前后端分离”的真正内涵和实现方法。由此,已经不需要为任何一种客户端来单独开发后端模块了,有了web端的前后端分离,后端程序对任何客户端都是通用的。 因此,我决定再次修改着系列博文,从标题到内容。
    ——2020.11.04


    后记

    几年前,我在自己辛苦求索,花了近半个月把这一套东西弄通之后,写下了这一系列博文。目的在于给和我处境类似的初学者们一些指引,让大家少走一些弯路。

    如果发现了代码或者理论方面的错误,请直接回复,我会尽快修改博文,避免误导了大家。

    如果在实现中出现了自己难以解决的问题,我的邮箱是implementist@outlook.com

    展开全文
  • java获取服务器信息

    千次阅读 2017-01-16 10:42:51
    java获取服务器信息需要用到sigar.jar,但该jar在linux下依赖于libsigar-amd64-linux.so、libsigar-x86-linux.so。在window下依赖于sigar-amd64-winnt.dll、sigar-x86-winnt.dll。配置文件这存在这模拟系统命名的...

    java获取服务器信息需要用到sigar.jar,但该jar在linux下依赖于libsigar-amd64-linux.so、libsigar-x86-linux.so。在window下依赖于sigar-amd64-winnt.dll、sigar-x86-winnt.dll。配置文件这存在这模拟系统命名的操作,可以通过这些系统命名来获取系统的参数。


    默认情况下是将依赖文件放在jdk下的lib包中,这样项目启动的时候会自动加载这些配置文件。但每个人使用就需要这么配置,太麻烦了,为了方便我们写一个公共类来优化这一问题。

    package com.dhcc.isccore.common.util;
    
    import java.io.File;
    
    import org.hyperic.sigar.Sigar;
    
    import com.dhcc.isccore.common.constant.IsccoreConstant;
    
    public class SigarUtils {
    	public final static Sigar sigar = initSigar();
    
    	public static Sigar initSigar() {
    		try {
    			File classPath = new File(IsccoreConstant.SIGAR_PATH);
    
    			String path = System.getProperty("java.library.path");
    			String sigarLibPath = classPath.getCanonicalPath();
    			// 为防止java.library.path重复加,此处判断了一下
    			if (!path.contains(sigarLibPath)) {
    				if (isOSWin()) {
    					path += ";" + sigarLibPath;
    				} else {
    					path += ":" + sigarLibPath;
    				}
    				System.setProperty("java.library.path", path);
    			}
    			return new Sigar();
    		} catch (Exception e) {
    			return null;
    		}
    	}
    
    	public static boolean isOSWin() {// OS 版本判断
    		String OS = System.getProperty("os.name").toLowerCase();
    		if (OS.indexOf("win") >= 0) {
    			return true;
    		} else
    			return false;
    	}
    }
    
    文件存放位置如下:



    jar依赖:

    <dependency>
    	<groupId>org.hyperic</groupId>
    	<artifactId>sigar</artifactId>
    	<version>1.6.5.132</version>
    </dependency>


    获取服务器信息的vo类定义:

    package com.dhcc.isccore.entity.serverinfo;
    
    import java.util.Date;
    import java.util.List;
    
    import org.hyperic.sigar.NetInterfaceConfig;
    
    public class ServerInfoVo {
    
    	private String serverIP;		//服务器IP
    	private String serverURL;		//服务器Url
    	private String serverType;		//服务器类型
    	private Date serverTime;		//服务器时间
    	
    	private String osName;			//操作系统名称
    	private String osVersion;		//操作系统版本
    	private String userName;		//用户名称
    	private String userHome;		//用户主目录
    	private String osTimeZone;		//操作系统时区
    	
    	private String memTotal;		//物理内存总量
    	private String memUsed;			//已使用的物理内存
    	private String memFree;			//物理内存剩余量
    	
    	private int cpuNum;				//cpu总数
    	private List<CpuInfoVo> cpuList;//cpu信息
    	
    	private int netNum;			//网卡总数
    	private List<NetInterfaceConfig> netList;	//网卡信息
    	
    	private String javaPath;		//java安路径
    	private String javaVendor;		//java运行时供应商
    	private String javaVersion;		//java版本
    	private String javaName;		//java运行时名称
    	private String jvmVersion;		//java虚拟机版本
    	private String jvmTotalMemory;	//java虚拟机总内存
    	private String jvmFreeMemory;	//java虚拟机剩余内存
    	
    	private String databaseType;	//数据库类型
    	private String databaseVersion;	//数据库类型
    	private String databaseDriver;	//数据库驱动
    	private String driverVersion;	//数据库驱动版本
    	private String jdbcUrl;			//数据库连接url
    	
    	public String getServerIP() {
    		return serverIP;
    	}
    	public void setServerIP(String serverIP) {
    		this.serverIP = serverIP;
    	}
    	public String getServerURL() {
    		return serverURL;
    	}
    	public void setServerURL(String serverURL) {
    		this.serverURL = serverURL;
    	}
    	public String getServerType() {
    		return serverType;
    	}
    	public void setServerType(String serverType) {
    		this.serverType = serverType;
    	}
    	public String getOsName() {
    		return osName;
    	}
    	public void setOsName(String osName) {
    		this.osName = osName;
    	}
    	public String getOsVersion() {
    		return osVersion;
    	}
    	public void setOsVersion(String osVersion) {
    		this.osVersion = osVersion;
    	}
    	public String getUserName() {
    		return userName;
    	}
    	public void setUserName(String userName) {
    		this.userName = userName;
    	}
    	public String getUserHome() {
    		return userHome;
    	}
    	public void setUserHome(String userHome) {
    		this.userHome = userHome;
    	}
    	public String getOsTimeZone() {
    		return osTimeZone;
    	}
    	public void setOsTimeZone(String osTimeZone) {
    		this.osTimeZone = osTimeZone;
    	}
    	public String getJavaVendor() {
    		return javaVendor;
    	}
    	public void setJavaVendor(String javaVendor) {
    		this.javaVendor = javaVendor;
    	}
    	public String getJavaVersion() {
    		return javaVersion;
    	}
    	public void setJavaVersion(String javaVersion) {
    		this.javaVersion = javaVersion;
    	}
    	public String getJavaName() {
    		return javaName;
    	}
    	public void setJavaName(String javaName) {
    		this.javaName = javaName;
    	}
    	public String getJvmVersion() {
    		return jvmVersion;
    	}
    	public void setJvmVersion(String jvmVersion) {
    		this.jvmVersion = jvmVersion;
    	}
    	public String getJvmTotalMemory() {
    		return jvmTotalMemory;
    	}
    	public void setJvmTotalMemory(String jvmTotalMemory) {
    		this.jvmTotalMemory = jvmTotalMemory;
    	}
    	public String getJvmFreeMemory() {
    		return jvmFreeMemory;
    	}
    	public void setJvmFreeMemory(String jvmFreeMemory) {
    		this.jvmFreeMemory = jvmFreeMemory;
    	}
    	public String getDatabaseType() {
    		return databaseType;
    	}
    	public void setDatabaseType(String databaseType) {
    		this.databaseType = databaseType;
    	}
    	public String getDatabaseVersion() {
    		return databaseVersion;
    	}
    	public void setDatabaseVersion(String databaseVersion) {
    		this.databaseVersion = databaseVersion;
    	}
    	public String getDatabaseDriver() {
    		return databaseDriver;
    	}
    	public void setDatabaseDriver(String databaseDriver) {
    		this.databaseDriver = databaseDriver;
    	}
    	public String getDriverVersion() {
    		return driverVersion;
    	}
    	public void setDriverVersion(String driverVersion) {
    		this.driverVersion = driverVersion;
    	}
    	public String getJdbcUrl() {
    		return jdbcUrl;
    	}
    	public void setJdbcUrl(String jdbcUrl) {
    		this.jdbcUrl = jdbcUrl;
    	}
    	
    	public Date getServerTime() {
    		return serverTime;
    	}
    	public void setServerTime(Date serverTime) {
    		this.serverTime = serverTime;
    	}
    	public String getJavaPath() {
    		return javaPath;
    	}
    	public void setJavaPath(String javaPath) {
    		this.javaPath = javaPath;
    	}
    	public int getCpuNum() {
    		return cpuNum;
    	}
    	public void setCpuNum(int cpuNum) {
    		this.cpuNum = cpuNum;
    	}
    	public List<CpuInfoVo> getCpuList() {
    		return cpuList;
    	}
    	public void setCpuList(List<CpuInfoVo> cpuList) {
    		this.cpuList = cpuList;
    	}
    	public int getNetNum() {
    		return netNum;
    	}
    	public void setNetNum(int netNum) {
    		this.netNum = netNum;
    	}
    	public List<NetInterfaceConfig> getNetList() {
    		return netList;
    	}
    	public void setNetList(List<NetInterfaceConfig> netList) {
    		this.netList = netList;
    	}
    	public String getMemTotal() {
    		return memTotal;
    	}
    	public void setMemTotal(String memTotal) {
    		this.memTotal = memTotal;
    	}
    	public String getMemUsed() {
    		return memUsed;
    	}
    	public void setMemUsed(String memUsed) {
    		this.memUsed = memUsed;
    	}
    	public String getMemFree() {
    		return memFree;
    	}
    	public void setMemFree(String memFree) {
    		this.memFree = memFree;
    	}
    	
    }
    

    获取服务器信息的实现类:

    public void findServerInfo(BaseAbstractDto baseAbstractDto){
    	try {
    		SigarUtils.initSigar();			//初始化动态库链接路径
    		ServerInfoDto dto = super.getExactlyDto(baseAbstractDto);
    		Properties props=System.getProperties();
    		HttpServletRequest request = ServletActionContext.getRequest();
    		Runtime runTime = Runtime.getRuntime();
    		InetAddress address = InetAddress.getLocalHost();
    			
    		//服务信息
    		ServerInfoVo serverInfoVo = new  ServerInfoVo();
    		InetAddress.getLocalHost().getHostAddress();
    		serverInfoVo.setServerIP(address.getHostAddress());
    		serverInfoVo.setServerURL(
    				request.getScheme()					//请求头
    				+"://" + address.getHostAddress() 	//服务器地址  
    				+ ":"   
    				+ request.getServerPort()        	//端口号  
    				+ request.getContextPath());      	//项目名称 
    		ServletContext application = request.getSession().getServletContext();
    		serverInfoVo.setServerType(application.getServerInfo());
    		serverInfoVo.setServerTime(new Date());
    			
    		//操作系统
    		serverInfoVo.setOsName(props.getProperty("os.name")+"  "+props.getProperty("os.arch"));
    		serverInfoVo.setOsVersion(props.getProperty("os.version"));
    		serverInfoVo.setUserName(props.getProperty("user.name"));
    		serverInfoVo.setUserHome(props.getProperty("user.home"));
    		Calendar cal = Calendar.getInstance();
    		TimeZone timeZone = cal.getTimeZone();
    		serverInfoVo.setOsTimeZone(timeZone.getDisplayName());
    			
    		//Cpu
    		Sigar sigar = new Sigar();
    	        CpuInfo cpuInfos[] = sigar.getCpuInfoList();
    	        serverInfoVo.setCpuNum(cpuInfos.length);
    	        CpuPerc cpuList[] = sigar.getCpuPercList();
    	        List<CpuInfoVo> cpuVoList = new ArrayList<CpuInfoVo>();
    	        for(int m=0;m<cpuList.length;m++){
    	        	CpuInfoVo cpuInfoVo = new CpuInfoVo();
    	        	cpuInfoVo.setCpuMhz(cpuInfos[m].getMhz());
    	        	String cpuIdle = String.format("%.2f",cpuList[m].getIdle()*100)+"%";
    	        	cpuInfoVo.setCpuLdle(cpuIdle);
    	        	String cpuCombined = String.format("%.2f",cpuList[m].getCombined()*100)+"%";
    	        	cpuInfoVo.setCpuCombined(cpuCombined);
    	        	cpuVoList.add(cpuInfoVo);
    	        }
    	        serverInfoVo.setCpuList(cpuVoList);
    	        
    	        //网卡信息
    	        String netInfos[] = sigar.getNetInterfaceList();
    	        List<NetInterfaceConfig> netList = new ArrayList<NetInterfaceConfig>();
    	        for(int i=0;i<netInfos.length;i++){
    	        	NetInterfaceConfig netInfo = sigar.getNetInterfaceConfig(netInfos[i]); 
    	        	if((NetFlags.LOOPBACK_ADDRESS.equals(netInfo.getAddress()))  	//127.0.0.1 
                            || (netInfo.getFlags() == 0)  							//标识为0
                            || (NetFlags.NULL_HWADDR.equals(netInfo.getHwaddr()))	//MAC地址不存在
                            || (NetFlags.ANY_ADDR.equals(netInfo.getAddress()))		//0.0.0.0
    	        			){
    	        		continue;
    	        	}
    	        	netList.add(netInfo);
    	        }
    	        serverInfoVo.setNetNum(netList.size());
    	        serverInfoVo.setNetList(netList);
    	        
    	        //物理内存
    	        Mem mem = sigar.getMem();  
    	        serverInfoVo.setMemTotal((mem.getTotal()/(1024*1024))+"M");
    	        serverInfoVo.setMemUsed((mem.getUsed()/(1024*1024))+"M");
    	        serverInfoVo.setMemFree((mem.getFree()/(1024*1024))+"M");
    	        
    		//java配置
    		serverInfoVo.setJavaPath(props.getProperty("java.home"));
    		serverInfoVo.setJavaVendor(props.getProperty("java.vendor"));
    		serverInfoVo.setJavaVersion(props.getProperty("java.version"));
    		serverInfoVo.setJavaName(props.getProperty("java.specification.name"));
    		serverInfoVo.setJvmVersion(props.getProperty("java.vm.version"));
    		serverInfoVo.setJvmTotalMemory((int)(runTime.totalMemory()/(1024*1024))+"M");
    		serverInfoVo.setJvmFreeMemory((int)(runTime.freeMemory()/(1024*1024))+"M");
    			
    			//数据库信息
    		findDatabase(serverInfoVo);
    		dto.setServerInfoVo(serverInfoVo);
    			
    	} catch (Exception e) {
    		e.printStackTrace();
    	}
    }
    
    //数据库连接信息
    public void findDatabase(ServerInfoVo serverInfoVo){
    	try{
    		PropertiesUtil propertiesUtil = PropertiesUtil.getInstance("hibernate.properties");//读取配置文件的连接信息
    		String driver = propertiesUtil.getProperty("jdbc.driver");
    		String jdbcUrl = propertiesUtil.getProperty("jdbc.url");
    		serverInfoVo.setJdbcUrl(jdbcUrl);
    		String username = propertiesUtil.getProperty("jdbc.username");
    		String password = propertiesUtil.getProperty("jdbc.password");
    		Class.forName(driver);
    		Connection con = (Connection) DriverManager.getConnection(jdbcUrl,username,password);
    		DatabaseMetaData metaData = (DatabaseMetaData) con.getMetaData();
    		serverInfoVo.setDatabaseType(metaData.getDatabaseProductName());
    		serverInfoVo.setDatabaseVersion(metaData.getDatabaseProductVersion());
    		serverInfoVo.setDatabaseDriver(metaData.getDriverName());
    		serverInfoVo.setDriverVersion(metaData.getDriverVersion());
    	}catch(Exception e){
    		e.printStackTrace();
    	}
    }
    

    显示效果如下:



    上诉方案主要讲解服务器信息的实现方法,不要全抄代码,部分无关紧要的代码并未上传,仅供参考,谢谢!



    展开全文
  • Java写一个简单的Web服务器Socket实现

    万次阅读 多人点赞 2018-06-06 14:55:53
    Java写一个简单的Web服务器Socket实现   一、实现思路 1、使用 ServerSocket 监听某一端口,然后等待连接获取 Socket对象。 2、创建一个类 HttpServer 继承 java.lang.Thread 类,重写 run()方法,执行浏览器...

                        Java写一个简单的Web服务器Socket实现

     

    一、实现思路

    1、使用 ServerSocket 监听某一端口,然后等待连接获取 Socket对象。

    2、创建一个类 HttpServer 继承 java.lang.Thread 类,重写 run()方法,执行浏览器请求。

    3、获得浏览器请求,解析资源文件路径。

    4、读取资源文件,响应给浏览器。

     

    二、代码实现

    1、ServerSocket 监听端口,获取 Socket对象

    package com.httpserver.two;
    import java.io.IOException;
    import java.net.ServerSocket;
    import java.net.Socket;
    /**
     * @description: 使用socket 自己写一个web服务器 ---监听端口,获取socket 对象。
     * @version:v1.0
     * @author:w
     * @date:2018年6月6日上午11:03:36
     *
     */
    public class WebServer {
    	public void startServer(int port){
    		try {
    			@SuppressWarnings("resource")
    			ServerSocket serverSocket = new ServerSocket(port);
    			while(true){
    				Socket socket = serverSocket.accept();
    				new HttpServer(socket).start();
    			}
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    }

     

     

    2、HttpServer.java类 --- 具体作用看方法注释。

    package com.httpserver.two;
    
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.net.Socket;
    
    /**
     * @description: 使用socket 实现 web服务器 --- 具体执行读写操作的。
     * @version:v1.0
     * @author:w
     * @date:2018年6月6日上午11:06:20
     *
     */
    public class HttpServer extends Thread {
    	/**
    	 * web资源根路径
    	 */
    	public static final String ROOT = "c:/";
    	
    	/**
    	 * 输入流对象,读取浏览器请求
    	 */
    	private InputStream input;
    	
    	/**
    	 * 输出流对象,响应内容给浏览器
    	 */
    	private OutputStream out;
    
    	/**
    	 * @description:初始化socket对象,获取对应 输入,输出流
    	 * @param socket
    	 */
    	public HttpServer(Socket socket) {
    		try {
    			input = socket.getInputStream();
    			out = socket.getOutputStream();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    
    	/**
    	 * 多线程方法调用
    	 */
    	@Override
    	public void run() {
    		String filePath = read();
    		response(filePath);
    	}
    
    	/**
    	 * @description: 读取资源文件,响应给浏览器。
    	 * @param:@param filePath
    	 *                   资源文件路径
    	 * @return:void
    	 * @version:v1.0
    	 * @author:w
    	 * @date:2018年6月6日 上午11:42:37
    	 *
    	 */
    	private void response(String filePath) {
    		File file = new File(ROOT + filePath);
    		if (file.exists()) {
    			// 1、资源存在,读取资源
    			try {
    				BufferedReader reader = new BufferedReader(new FileReader(file));
    				StringBuffer sb = new StringBuffer();
    				String line = null;
    				while ((line = reader.readLine()) != null) {
    					sb.append(line).append("\r\n");
    				}
    				StringBuffer result = new StringBuffer();
    				result.append("HTTP /1.1 200 ok /r/n");
    				result.append("Content-Type:text/html /r/n");
    				result.append("Content-Length:" + file.length() + "/r/n");
    				result.append("\r\n:" + sb.toString());
    				out.write(result.toString().getBytes());
    				out.flush();
    				out.close();
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    
    		} else {
    			// 2、资源不存在,提示 file not found
    			StringBuffer error = new StringBuffer();
    			error.append("HTTP /1.1 400 file not found /r/n");
    			error.append("Content-Type:text/html \r\n");
    			error.append("Content-Length:20 \r\n").append("\r\n");
    			error.append("<h1 >File Not Found..</h1>");
    			try {
    				out.write(error.toString().getBytes());
    				out.flush();
    				out.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    
    	}
    
    	/**
    	 * 
    	 * @description:解析资源文件路径
    	 * @example: GET /index.html HTTP/1.1
    	 * @param:@return
    	 * @return:String
    	 * @version:v1.0
    	 * @author:w
    	 * @date:2018年6月6日 上午11:39:42
    	 *
    	 */
    	private String read() {
    		BufferedReader reader = new BufferedReader(new InputStreamReader(input));
    		try {
    			// 读取请求头, 如:GET /index.html HTTP/1.1
    			String readLine = reader.readLine();
    			String[] split = readLine.split(" ");
    			if (split.length != 3) {
    				return null;
    			}
    			System.out.println(readLine);
    			return split[1];
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    		return null;
    	}
    
    }

    三、代码测试

    1、启动服务器

    public static void main(String[] args) {
        new WebServer().startServer(8000);
    }

     

    2、浏览器地址栏输入: http://localhost:8000/index.html

     

    3、效果如下:

     

        

     

    四、总结

    1、该示例代码可直接粘贴IDE中运行,无需任何第三方jar包。 简单简洁,便于理解。

    2、c盘中,必须有一个 index.html的文件,若存放在其他位置,请修改 HttpServer.ROOT字段,路径位置即可。

    3、若出现请求成功,响应页面为空白,请去掉 index.html 页面的 <html>标签试试。--- 至于什么问题导致的,目前还不清楚。 -_-!

    4、 index.html 代码参考

                

    <!DOCTYPE html>
    <head>
    <meta charset="UTF-8">
    <title>Insert title here</title>
    </head>
    <body>
    	<h1>Hello World! this is my webserver!</h1>
    </body>
    

     

    五、遗留问题解决

    1、若出现请求成功,响应页面为空白,请去掉 index.html 页面的 <html>标签试试。原因是:换行符"\r\n"写错了,写成了"/r/n" 。

    2、Firefox无法解析。原因是:"HTTP /1.1 200 ok" 中,"HTTP"和"/1.1" 直接不能有空格,否则 Firefox无法解析 。正确的是: "HTTP/1.1 200 ok"。

    3、关于换行符问题补充: 

    a. windows 换行符: "\r\n

    b. linux 换行符: "\n

    c. mac 换行符:"\r"

               4、可能引发问题: 假设在 linux 中,使用 windows的换行符会有效果吗?会引发上述的问题吗?

    5、造成上述问题的发生,主要是 response header 不对导致的,chrome 浏览器可查看 response header 如下图:

     

    六、补上修改后的代码 

    package com.httpserver.two.fix;
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.File;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.OutputStreamWriter;
    import java.net.Socket;
    /**
     * @description: 使用socket 实现 web服务器 --- 具体执行读写操作的。<br>
     * 	fix: 1、换行符写错误:"/r/n" 调整为正确: "\r\n"。 <br>
     * 		 2、"HTTP /1.1 200 ok" 中,"HTTP"和"/1.1" 直接不能有空格,否则 Firefox无法解析。<br>
     * @version:v1.1
     * @author:w
     * @date:2018年12月18日 16:50:28
     */
    public class HttpServerFix extends Thread {
    	/**
    	 * web资源根路径
    	 */
    	public static final String ROOT = "c:/";
    	
    	/**
    	 * 输入流对象,读取浏览器请求
    	 */
    	private InputStream input;
    	
    	/**
    	 * 输出流对象,响应内容给浏览器
    	 */
    	private OutputStream out;
    
    	/**
    	 * @description:初始化socket对象,获取对应 输入,输出流
    	 * @param socket
    	 */
    	public HttpServerFix(Socket socket) {
    		try {
    			input = socket.getInputStream();
    			out = socket.getOutputStream();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    
    	/**
    	 * 多线程方法调用
    	 */
    	@Override
    	public void run() {
    		String filePath = read();
    		response(filePath);
    	}
    
    	/**
    	 * @description: 读取资源文件,响应给浏览器。
    	 * @param:@param filePath
    	 *                   资源文件路径
    	 * @return:void
    	 * @version:v1.0
    	 * @author:w
    	 * @date:2018年6月6日 上午11:42:37
    	 *
    	 */
    	private void response(String filePath) {
    		File file = new File(ROOT + filePath);
    		if (file.exists()) {
    			// 1、资源存在,读取资源
    			try {
    				BufferedReader reader = new BufferedReader(new FileReader(file));
    				StringBuffer sb = new StringBuffer();
    				String line = null;
    				while ((line = reader.readLine()) != null) {
    					System.out.println("line:"+ line);
    					sb.append(line).append("\r\n");
    				}
    				StringBuffer result = new StringBuffer();
    				/**
    				 * 1、 换行符"/r/n"写错了,正确的是: "\r\n"
    				 * 2、"HTTP /1.1 ..."之间不能有空格,否则Firfox不能解析
    				 * 3、 关于换行符的补充:
    				 * 	  a.windows:"\r\n"
    				 *    b.linux:"\n"
    				 *    c.mac:"\r" 
    				 */
    			//	result.append("HTTP /1.1 200 ok /r/n");
    				result.append("HTTP/1.1 200 ok \r\n");
    				result.append("Content-Language:zh-CN \r\n");
    				// charset=UTF-8 解决中文乱码问题
    				result.append("Content-Type:text/html;charset=UTF-8 \r\n");
    				result.append("Content-Length:" + file.length() + "\r\n");
    				result.append("\r\n" + sb.toString());
    				out.write(result.toString().getBytes());
    				out.flush();
    				out.close();
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    
    		} else {
    			// 2、资源不存在,提示 file not found
    			StringBuffer error = new StringBuffer();
    			error.append("HTTP/1.1 400 file not found \r\n");
    			error.append("Content-Type:text/html \r\n");
    			error.append("Content-Length:20 \r\n").append("\r\n");
    			error.append("<h1 >File Not Found..</h1>");
    			try {
    				out.write(error.toString().getBytes());
    				out.flush();
    				out.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    
    	}
    
    	/**
    	 * 
    	 * @description:解析资源文件路径
    	 * @example: GET /index.html HTTP/1.1
    	 * @param:@return
    	 * @return:String
    	 * @version:v1.0
    	 * @author:w
    	 * @date:2018年6月6日 上午11:39:42
    	 *
    	 */
    	private String read() {
    		BufferedReader reader = new BufferedReader(new InputStreamReader(input));
    		try {
    			// 读取请求头, 如:GET /index.html HTTP/1.1
    			String readLine = reader.readLine();
    			String[] split = readLine.split(" ");
    			if (split.length != 3) {
    				return null;
    			}
    			System.out.println(readLine);
    			return split[1];
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    		return null;
    	}
    
    }
    

     

    最后,感谢 Vito_w7 的指点迷津!

     

    展开全文
  • java游戏服务器必备

    千次阅读 2018-12-28 16:41:44
    对于一个新手,想接触游戏服务器,一定会有个疑问——使用Java开发服务器需要学习什么? &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Java语言,由于学习成本低,开发速度快,稳定
  • 经常看到各种容器名称:Servlet容器、WEB容器、Java WEB容器、Java EE容器等,还有各种服务器名称:应用服务器、WEB服务器、WEB应用服务器Java WEB应用服务器Java EE服务器等, 下面我们尝试区分它们,找出他们...
  • java mqtt服务器搭建

    千次阅读 2020-10-03 15:28:02
    MQTT服务器搭建和客户端代码编写(java实现) 服务器 关于linux系统,可以在阿里云购买云服务器或者利用虚拟机安装CentOs系统。我用的就是阿里云的云服务器,比较方便吧 安装Emqx服务器 安装必要的依赖: $ sudo yum ...
  • Java游戏服务器开发之二--导航帖

    万次阅读 2018-06-29 16:12:08
    Java游戏服务器开发之三--日志  Java游戏服务器开发之四--通讯框架netty    Java游戏服务器开发之五--使用工厂模式生成netty     Java游戏服务器开发之六--整合spring   Java游戏服务器开发之七--使用...
  • Java写文件到ftp服务器

    千次阅读 2018-02-07 17:37:30
    // 如果采用默认端口,可以使用ftp.connect(host)的方式直接连接FTP服务器 ftp.login(username, password);// 登录 reply = ftp.getReplyCode(); if (!FTPReply.isPositiveCompletion(reply)) { ftp....
  • Java游戏服务器搭建

    千次阅读 2019-03-19 20:26:03
    此游戏服务器架构是一个单服的形式,也就是说所有游戏逻辑在一个工程里,没有区分登陆服务器、战斗服务器、世界服务器等。此架构已成功应用在了多款页游服务器 。在此框架中没有实现相关业务逻辑,只有简单的测试用...
  • JAVA写HTTP代理服务器(一)-socket实现

    万次阅读 2017-09-04 16:12:40
    HTTP代理服务器是一种特殊的网络服务,允许一个网络终端(一般为客户端)通过这个服务与另一个网络终端(一般为服务器)进行非直接的连接。一些网关、路由器等网络设备具备网络代理功能。一般认为代理服务有利于保障...
  • java连接服务器

    千次阅读 2018-03-20 14:55:02
    Server.java package com.lisa.server; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.ServerSocket; import java.net.Socket; import java.la...
  • Java获取服务器根目录

    千次阅读 2016-05-10 10:28:18
    获取Java服务器的根目录
  • JAVA应用服务器都有那些?

    千次阅读 2019-11-05 22:52:47
    从功能上看分为两种:web应用服务器java EE服务器 web服务器 * Tomcat、Jetty、Orion、Resin、 Bejy Tiger、Geronimo、Jonas、Jrun java EE 服务器 TongWeb 、BES Application Server 、 Apusic Application ...
  • java 开发服务器

    千次阅读 2011-09-10 14:05:19
    1、 怎样分析服务器的需求? 2、 怎样规划服务器的架构? 3、 怎样规划服务器的目录及命名规范、开发代号? 4、 原型的开发(-): 怎样设计服务器的代码骨架? 5、 原型的开发(二): 怎样测试您的代码骨架...
  • JAVA写HTTP代理服务器(二)-netty实现

    万次阅读 2017-09-04 16:13:49
    接上一篇,因为是用BIO的一个连接一个线程去处理,对于HTTP这种短连接协议来说CPU开销是非常大的,就算加入了线程池也不能完美解决BIO的缺陷,所以可以用NIO进行服务器的优化,NIO基于IO多路复用以实现单线程处理大量...
  • 前面两章介绍了 MinIO 文件服务器的环境搭建,以及在 Java 中上传文件至 MinIO 文件服务器中,现在,一起来看下如何从 MinIO 文件服务器中下载文件吧 1、获取文件对象 我们在 MinIO 工具类中,获取文件对象的方法,...
  • 常用的java应用服务器大概介绍

    万次阅读 2016-12-27 13:59:29
    何为应用服务器呢?它主要为应用程序提供运行环境,为组件... 应用服务器Java EE 应用服务器。相对来说 Java EE 服务器的功能更加强大。 WEB 服务器 Tomcat 、Bejy Tiger 、Geronimo 、 Jetty 、Jonas 、Jru
  • 常用的java应用服务器

    千次阅读 2014-04-30 11:40:31
    Java 的应用服务器很多,从功能上分为两类:WEB 应用服务器Java EE 应用服务器。相对来说 Java EE 服务器的功能更加强大。 WEB 服务器  Tomcat 、Bejy Tiger 、Geronimo 、 Jetty 、Jonas 、Jrun 、Or
  • JAVA 的多服务器通讯框架,目前实现AccountServer,GatewayServer,GlobalServer,RecordServer,SessionServer和Client的框架代码,可以实现简单的命令行发送文字,接下来是要优化性能和增加相应的功能。...
  • 利用java语言一个服务器

    千次阅读 2016-10-25 17:59:15
    import java.net.*; import java.io.*;... * 简单服务器 */ public class Server{ public static void main(String []args) throws Exception{ ServerSocket server = new ServerSocket(9999); ...
  • Java游戏服务器开发之十六--byte消息传输 消息传输可以看看这篇游戏中tcp消息使用byte字节数组传输   上面的代码在码云上 https://gitee.com/lizhaoandroid/JgServer 可以加qq群一起探讨Java游戏服务器开发的...
  • 首先探讨一下为什么要使用nginx:1、类似于apache+resin,nginx用于提供静态页面服务,比java服务器要强。虽然这些java服务器的性能都不赖,tomcat新版甚至还支持了epoll,但是用nginx来处理静态文件是一定比这些...
  • java服务器端和客户端之间简单的通信

    千次阅读 多人点赞 2018-05-13 17:04:48
    最近因为作业的需要,老师让用java语言一个关于服务器端和客户端之间简单的通信,所以就有了这一篇文章 准备工作: 博主是在eclipse工具下进行操作的。 程序代码如下所示 1:客户端 import java.awt.*; ...
  • 准备一个web服务器专门供宿舍看电影用。 之前已经实现基本的web服务器,今天又把视频播放器弄好了,接下来就是整合了。 视频播放器,用的CuPlayer,改改demo就行,之前不成功可能是没在localhost下测试,视频是...
  • Java游戏服务器开发之十-消息处理器INetworkConsumer 有了session我们就可以在任何地方向客户端发送信息 好了session,可以一个对消息的处理类(消费者)。 add INetworkConsumer NetworkConsumer update ...
  • java服务器,android做客户端,实现数据传输

    万次阅读 热门讨论 2014-03-09 08:10:42
    许久未动笔,有个小...简单起见,用java写这个服务器,以前没做过,试试水。很简单的代码,纯粹找思路。 服务器端代码: package com.test; import java.io.IOException; import java.io.OutputStream; impor

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,556,055
精华内容 622,422
关键字:

java写服务器

java 订阅