精华内容
下载资源
问答
  • Java反射机制DOME

    2019-10-07 07:13:05
    Java反射机制 public class TestHibernate { @Test public void TestHb(){ try { Class cs = Class.forName("testHibernate.Test1"); //classload 类 Object o...
    Java反射机制
    public class TestHibernate {
        @Test
        public void TestHb(){
            try {
                Class cs = Class.forName("testHibernate.Test1");    //classload 类 
                Object oj = cs.newInstance();                        //通过类NEW一个对象
                Method[] mt = cs.getMethods();                        //获取所有方法
                for (Method method : mt) {                            //轮询出所有函数方法
                    if(method.getName()=="m13"){                    //通过函数名判断函数
                        method.invoke(oj,1,2);
                        for(Class parameter:method.getParameterTypes()){    //轮询出函数方法的参数
                        System.out.println(parameter.getName());            //获取参数类型
                        }
                        System.out.println("返回值"+method.getReturnType());    //获取返回值类型
                    }else if(method.getName()=="m12"){
                        method.invoke(oj);                            //执行函数方法无参
                    }else if(method.getName()=="getmeth"){
                        System.out.println("123"+method.getReturnType());
                        Object object = method.invoke(oj);            //获取函数方法返回的类对象
                        Class ccc = object.getClass();                //通过类对象获得类
                        Field ff = ccc.getField("x2");             //获取变量对象
                         int x1 = (int)ff.get(object);                //获取属性值
                        //getDeclaredMethod可获取私有方法
                        Method met = ccc.getDeclaredMethod("xxx",new Class[]{int.class,int.class});
                        
                        met.setAccessible(true);//设置可成 可访问
                        Object i = met.invoke(object, x1,2);//调用带参函数方法
                        System.out.println(i+"xxxxxxxxxxxxxxxxxxxxxxxxxx");
                    }
                    
                }    
            } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | SecurityException | NoSuchMethodException | NoSuchFieldException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }    
        }
    }
    class Test2{
        static{
            System.out.println("classLoad  test2");
        }
        public int x2 = 3;
        private int xxx(int x1,int x2){
            return x1*x2;
        }
    }
    class Test1{
        static{
            System.out.println("classLoad  test1");
        }
        {
            System.out.println("new objcet  tset1");
        }
        
        public Test2 getmeth(){
            return new Test2();
        }
        public void m12(){
            System.out.println("m12");
        }
        public String m13(int b,int r){
            System.out.println(b+r);
            return b+r+"";
        }
    }

    本dome为学习测试使用的

    Java反射机制

    public class TestHibernate {

    @Test

    public void TestHb(){

    try {

    Class cs = Class.forName("testHibernate.Test1");        //classload

    Object oj = cs.newInstance();                                                //通过类NEW一个对象

    Method[] mt = cs.getMethods();                                                //获取所有方法

    for (Method method : mt) {                                                        //轮询出所有函数方法

    if(method.getName()=="m13"){                                        //通过函数名判断函数

    method.invoke(oj,1,2);

    for(Class parameter:method.getParameterTypes()){        //轮询出函数方法的参数

    System.out.println(parameter.getName());                        //获取参数类型

    }

    System.out.println("返回值"+method.getReturnType());        //获取返回值类型

    }else if(method.getName()=="m12"){

    method.invoke(oj);                                                        //执行函数方法无参

    }else if(method.getName()=="getmeth"){

    System.out.println("123"+method.getReturnType());

    Object object = method.invoke(oj);                        //获取函数方法返回的类对象

    Class ccc = object.getClass();                                //通过类对象获得类

    Field ff = ccc.getField("x2");                         //获取变量对象

     int x1 = (int)ff.get(object);                                //获取属性值

    //getDeclaredMethod可获取私有方法

    Method met = ccc.getDeclaredMethod("xxx",new Class[]{int.class,int.class});

     

    met.setAccessible(true);//设置可成 可访问

    Object i = met.invoke(object, x1,2);//调用带参函数方法

    System.out.println(i+"xxxxxxxxxxxxxxxxxxxxxxxxxx");

    }

     

    }        

    } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | SecurityException | NoSuchMethodException | NoSuchFieldException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }        

    }

    }

    class Test2{

    static{

    System.out.println("classLoad  test2");

    }

    public int x2 = 3;

    private int xxx(int x1,int x2){

    return x1*x2;

    }

    }

    class Test1{

    static{

    System.out.println("classLoad  test1");

    }

    {

    System.out.println("new objcet  tset1");

    }

     

    public Test2 getmeth(){

    return new Test2();

    }

    public void m12(){

    System.out.println("m12");

    }

    public String m13(int b,int r){

    System.out.println(b+r);

    return b+r+"";

    }

    }

    转载于:https://www.cnblogs.com/b422/p/java_reflection.html

    展开全文
  • java-多文件上传dome

    2017-06-18 15:01:21
    多文件上传java工具包,直接下载可用
  • 目录前言流程图示Dome结构预览Message类服务端用户登录与查询与消息转发服务端代码客户端登录客户端消息接收与发送注意点客户端代码运行结果示意 前言 ...MessageType 是一个用来标注消息类型的 Mess

    前言

    这玩意就是一个基于TCP的建议聊天室,有服务端与客户端。服务端负责对客户端的数据进行转发至另一个客户端。当然前提是每一个客户端连接服务器的时候需要提供一个用户名,也就是需要进行超简陋的登录。

    流程图示

    功能示意
    在这里插入图片描述
    代码流程示意
    在这里插入图片描述

    Dome结构预览

    在这里插入图片描述
    Message是我们传递的数据,我们传递消息对象
    MessageType 是一个用来标注消息类型的

    Message类

    import java.io.Serializable;
    
    public class Message implements Serializable{
        private String from;//消息发送者
        private String to;//消息接收者
        private int type;//消息类型
        private String info;//发送的消息内容
    
        public Message(){
    
        }
        public Message(String from, String to, int type, String info) {
            this.from = from;
            this.to = to;
            this.type = type;
            this.info = info;
        }
        public String getFrom() {
            return from;
        }
        public void setFrom(String from) {
            this.from = from;
        }
        public String getTo() {
            return to;
        }
        public void setTo(String to) {
            this.to = to;
        }
        public int getType() {
            return type;
        }
        public void setType(int type) {
            this.type = type;
        }
        public String getInfo() {
            return info;
        }
        public void setInfo(String info) {
            this.info = info;
        }
        
    }
    
    

    type类

    public final class MessageType {
        public static final int TYPE_LOGIN = 0x1;//登录的消息类型
        public static final int TYPE_SEND = 0x2; //发送的消息类型
    }
    
    

    服务端用户登录与查询与消息转发

    先将用户处理的线程加入列表
    在这里插入图片描述
    更据消息类型做适当反馈,如果是发送消息,那么就直接遍历列表中的用户线程,对比线程的用户名是否与我们的发送对象相等,之后使用该用户线程的输出流发送msg对象,实现通信。
    在这里插入图片描述

    服务端代码

    
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.Vector;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    
    public class Server {
        //服务器端负责数据的中转
        public static void main(String[] args) {
            ExecutorService es = Executors.newFixedThreadPool(6);//线程池大小最多同时支持6个人聊天
            Vector<UserThread> vector = new Vector<>();//存储客户端线程
            try{
            ServerSocket server = new ServerSocket(8888);
            System.out.println("服务器已启动......");
            while(true){
                Socket socket = server.accept();
                UserThread user = new UserThread(socket,vector);
                es.execute(user);
    
            }
        }catch(IOException e){
            e.printStackTrace();
        }
            
        }
        
    }
    
    class UserThread implements Runnable{
        private Socket socket;
        private Vector<UserThread> vector;
        private String name;
        private ObjectInputStream ois;
        private ObjectOutputStream oos;
        private boolean flag=true;
        public UserThread(Socket socket, Vector<UserThread> vector) {
            this.socket = socket;
            this.vector = vector;
            this.vector.add(this);
        }
        public UserThread() {
        }
        @Override
        public void run() {
            // TODO Auto-generated method stub
            try{
            System.out.println("[Host:"+socket.getInetAddress().getHostAddress()+"-连接]");
            ois = new ObjectInputStream(socket.getInputStream());
            oos = new ObjectOutputStream(socket.getOutputStream());
            while(flag){
    
                Message msg = (Message) ois.readObject();
                int type = msg.getType();
                switch(type){
                    case MessageType.TYPE_LOGIN:{
                        //登录
                        this.name = msg.getFrom();
                        msg.setInfo("欢迎你:"+this.name);
                        oos.writeObject(msg);
                        break;
                    }
                    case MessageType.TYPE_SEND:{
                        //发送消息
                        String sendto = msg.getTo();
                        for(UserThread user:vector){
                            if(sendto.equals(user.name)&&user!=this){
                                //寻找
                                user.oos.writeObject(msg);
                                System.out.println(this.name+"send message to"+msg.getTo()+"--success");
                                break;
                            }
                            else{
                                System.out.println(this.name+"send message to"+msg.getTo()+"--fail");
                            }
                        }
                        break;
                    }
                }
            }
            oos.close();
            ois.close();
            }catch(IOException | ClassNotFoundException e){
                // e.printStackTrace();
                System.out.println("Closed"+name);
                return;
            }
    
            
        }
        
    
    }
    

    客户端登录

    登录
    在这里插入图片描述
    登录后在服务端会发送欢迎消息,所以需要接收。
    在这里插入图片描述

    客户端消息接收与发送

    消息接收
    在这里插入图片描述
    消息接受专门在开了一个子线程负责接收消息并展示
    在这里插入图片描述
    在这里插入图片描述
    消息发送
    这个的话我们直接在主线程当中进行发送即可
    在这里插入图片描述

    注意点

    当客户端关闭后,我们在服务端的子线程必须关闭,否则继续运行会浪费内存。这里的话,在客户端关闭后,会在我们的服务端抛出IOException异常,那么我在在抛出异常后关闭即可。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    客户端代码

    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.net.Socket;
    import java.util.Scanner;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class Client {
        public static void main(String[] args) {
            ExecutorService es = Executors.newSingleThreadExecutor();
            Scanner input  = new Scanner(System.in);
            try{
                Socket socket = new Socket("localhost",8888);
                System.out.println("已连接至服务器");
                ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
                ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
                //登录
                System.out.print("请输入用户名:");
                String username = input.nextLine();
                Message msg = new Message(username,null,MessageType.TYPE_LOGIN,null);
                oos.writeObject(msg);
                msg = (Message)ois.readObject();
                System.out.println(msg.getInfo());
                //与其他用户接收发送交流消息
                //读取其他用户的消息
                // new Thread(new ReadInfoThread(ois)).start();
                es.execute(new ReadInfoThread(ois));
                //发送直接在主线程发送
                boolean flag = true;
                while(flag){
                    msg = new Message();
                    System.out.print("To:");
                    msg.setTo(input.nextLine());
                    msg.setFrom(username);
                    msg.setType(MessageType.TYPE_SEND);
                    System.out.print("\nmsg:");
                    msg.setInfo(input.nextLine());
                    oos.writeObject(msg);
                }
    
    
    
            }catch(IOException | ClassNotFoundException e){
                e.printStackTrace();
            }
        }
    }
    
    class ReadInfoThread implements Runnable{
        private ObjectInputStream ois;
        private boolean flag = true;
        public ReadInfoThread(ObjectInputStream ois){
            this.ois = ois;
        }
        @Override
        public void run() {
            // TODO Auto-generated method stub
            try {
    
                while(flag){
                Message msg=(Message)ois.readObject();
                System.out.println();
                System.out.println("From:["+msg.getFrom()+"]say:"+msg.getInfo());
                System.out.print("To:");
                }
                if(ois!=null){
                    ois.close();
                }
    
            } catch (ClassNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
    }
    
    

    运行结果示意

    在这里插入图片描述

    展开全文
  • package com.tian.batis... import java.io.UnsupportedEncodingException; import java.net.URLEncoder; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import ja...
    package com.tian.batis;
    
    import java.io.UnsupportedEncodingException;
    import java.net.URLEncoder;
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import org.apache.commons.codec.digest.DigestUtils;
    import javax.servlet.http.HttpServletResponse;
    
    public class alipay {
        /**
         * alipay 支付接口
         * 
         * @param _input_charset
         *            编码
         * @param subject
         *            商品名 (必填)
         * @param notify_url
         *            异步执行地址
         * @param body
         *            商品描述
         * @param payment_type
         *            付款类型
         * @param out_trade_no
         *            订单号 (必填)
         * @param partner
         *            商家id
         * @param service
         *            服务
         * @param total_fee
         *            金额 (必填)
         * @param return_url
         *            返回展示地址
         * @param sign_type
         *            加密方式(默认md5)
         * @param seller_id
         *            同商家id
         * @param response
         * @param sessionId
         *            sessionId
         * @return 成功 返回url;-1失败(参数);-2处理异常
         */
        public String AlipayPayment(String _input_charset, String subject, String notify_url, String body,
                String payment_type, String out_trade_no, String partner, String service, Integer total_fee,
                String return_url, String sign_type, String seller_id, HttpServletResponse response, String sessionId) {
            try {
                String strSandbox = "https://mapi.alipay.com/gateway.do";// 地址
                ConfigManager configManager = ConfigManager.getInstance("alipayconfig.properties");
    
                Map<String, String> map = new HashMap<String, String>();
    
                if (null != subject && subject.trim().length() > 0) {
                    map.put("subject", subject);
                } else {
                    return "-1";
                }
    
                if (null != out_trade_no && out_trade_no.trim().length() > 0) {
                    map.put("out_trade_no", out_trade_no);
                } else {
                    return "-1";
                }
    
                if (null != total_fee && total_fee > 0) {
                    map.put("total_fee", total_fee + "");
                    // map.put("total_fee", "0.01");
                } else {
                    return "-1";
                }
    
                if (null != _input_charset && _input_charset.trim().length() > 0) {
                    map.put("_input_charset", _input_charset);
                } else {
                    map.put("_input_charset", configManager.getConfigItem("alipay._input_charset").toString());
                }
    
                if (null != notify_url && notify_url.trim().length() > 0) {
                    map.put("notify_url", notify_url);
                } else {
                    map.put("notify_url", configManager.getConfigItem("alipay.notify_url1").toString());
                }
    
                if (null != return_url && return_url.trim().length() > 0) {
                    map.put("return_url", return_url);
                } else {
                    map.put("return_url", configManager.getConfigItem("alipay.return_url").toString());
                }
    
                if (null != payment_type && payment_type.trim().length() > 0) {
                    map.put("payment_type", payment_type);
                } else {
                    map.put("payment_type", configManager.getConfigItem("alipay.payment_type").toString());
                }
    
                if (null != partner && partner.trim().length() > 0) {
                    map.put("partner", partner);
                } else {
                    map.put("partner", configManager.getConfigItem("alipay.partner").toString());
                }
    
                if (null != service && service.trim().length() > 0) {
                    map.put("service", service);
                } else {
                    map.put("service", configManager.getConfigItem("alipay.service").toString());
                }
    
                if (null != sign_type && sign_type.trim().length() > 0) {
                    map.put("sign_type", sign_type);
                } else {
                    map.put("sign_type", configManager.getConfigItem("alipay.sign_type").toString());
                }
    
                if (null != seller_id && seller_id.trim().length() > 0) {
                    map.put("seller_id", seller_id);
                } else {
                    map.put("seller_id", configManager.getConfigItem("alipay.seller_id").toString());
                }
    
                if (null != body && body.trim().length() > 0) {
                    map.put("body", body);
                }
    
                if (null != sessionId && sessionId.trim().length() > 0) {
                    map.put("extra_common_param", sessionId);
                }
    
                Map<String, String> sPara = paraFilter(map);
                // 生成签名结果
                String sign = buildRequestMysign(sPara, configManager.getConfigItem("alipay.key").toString(),
                        configManager.getConfigItem("alipay._input_charset").toString());
                map.put("sign", sign);
    
                String str = "";
                for (Map.Entry<String, String> entry : map.entrySet()) {
                    String key = entry.getKey();
                    String value = entry.getValue();
                    if (key.equals("subject") || key.equals("body")) {
                        value = URLEncoder.encode(value, "UTF-8");
                    }
                    if (null != str && str.trim().length() > 0) {
                        str += "&" + key + "=" + value;
                    } else {
                        str += key + "=" + value;
                    }
                }
    
                String url = strSandbox;
                if (null != str && str.trim().length() > 0) {
                    url += "?" + str;
                }
                return url;
                // 注:如果失败考虑
                // 1.response 重定向编码
                // 2.sign_type 放置参数末尾
                // 3.url 追加 _input_charset=utf-8
            } catch (Exception e) {
                e.printStackTrace();
                return "-2";
            }
        }
        ///
        /**
         * 除去数组中的空值和签名参数
         * 
         * @param sArray
         *            签名参数组
         * @return 去掉空值与签名参数后的新签名参数组
         */
        public static Map<String, String> paraFilter(Map<String, String> sArray) {
            Map<String, String> result = new HashMap<String, String>();
            if (sArray == null || sArray.size() <= 0) {
                return result;
            }
            for (String key : sArray.keySet()) {
                String value = sArray.get(key);
                if (value == null || value.equals("") || key.equalsIgnoreCase("sign")
                        || key.equalsIgnoreCase("sign_type")) {
                    continue;
                }
                result.put(key, value);
            }
            return result;
        }
        
        /**
         * 生成签名结果
         * 
         * @param sPara
         *            要签名的数组
         * @return 签名结果字符串
         */
        public static String buildRequestMysign(Map<String, String> sPara, String key, String input_charset) {
            String prestr = createLinkString(sPara); // 把数组所有元素,按照“参数=参数值”的模式用“&”字符拼接成字符串
            String mysign = "";
            mysign = sign(prestr, key, input_charset);
            return mysign;
        }
        
        /**
         * 把数组所有元素排序,并按照“参数=参数值”的模式用“&”字符拼接成字符串
         * 
         * @param params
         *            需要排序并参与字符拼接的参数组
         * @return 拼接后字符串
         */
        public static String createLinkString(Map<String, String> params) {
            List<String> keys = new ArrayList<String>(params.keySet());
            Collections.sort(keys);
            String prestr = "";
            for (int i = 0; i < keys.size(); i++) {
                String key = keys.get(i);
                String value = params.get(key);
    
                if (i == keys.size() - 1) {// 拼接时,不包括最后一个&字符
                    prestr = prestr + key + "=" + value;
                } else {
                    prestr = prestr + key + "=" + value + "&";
                }
            }
            return prestr;
        }
        /**
         * 签名字符串
         * 
         * @param text
         *            需要签名的字符串
         * @param key
         *            密钥
         * @param input_charset
         *            编码格式
         * @return 签名结果
         */
        public static String sign(String text, String key, String input_charset) {
            text = text + key;
            return DigestUtils.md5Hex(getContentBytes(text, input_charset));
        }
        
        /**
         * @param content
         * @param charset
         * @return
         * @throws SignatureException
         * @throws UnsupportedEncodingException
         */
        private static byte[] getContentBytes(String content, String charset) {
            if (charset == null || "".equals(charset)) {
                return content.getBytes();
            }
            try {
                return content.getBytes(charset);
            } catch (UnsupportedEncodingException e) {
                throw new RuntimeException("MD5签名过程中出现错误,指定的编码集不对,您目前指定的编码集是:" + charset);
            }
        }
    }

     

    转载于:https://www.cnblogs.com/suanshun/p/7357417.html

    展开全文
  • 目录Java流socket定义Java socket的使用客户端 Java流 在进行网络编程之前,我们一定要搞清楚,流这玩意对于Java来说是多么重要。我们可以通过流来完成文件的存储,读取,同时也通过流来对网络数据进行传输。在Java...

    Java流

    在进行网络编程之前,我们一定要搞清楚,流这玩意对于Java来说是多么重要。我们可以通过流来完成文件的存储,读取,同时也通过流来对网络数据进行传输。在Java当中没有指针的概念,我们知道在C语言当中它把所有的抽象的概念例如屏幕,键盘都看作了文件,对应就是指针(例如屏幕stdout标准输出,stdin标准输入)那么在Java当中流也充当了类似指针的作用。

    socket定义

    何为socket,这玩意其实就我们的网络驱动程序开放的接口,我们通过它来完成我们网络的连接数据的发生。当然在不同的计算机语言当中其具体的操作有细微的区别,例如在Java当中我们可以直接使用字符流来进行中文的直接传输,但是在python当中在传输时都必须先将数据转换为bytes,之后在对其进行解码。
    一,Java
    在这里插入图片描述
    二,python

        s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        id = socket.gethostbyname(socket.gethostname()).split(":")[0]
        s.connect((id,8089))
        s.send('你好!'.encode('utf8'))
        print("数据发送完成")
        tes=s.recv(1024)
        print(tes.decode('utf8'))
        s.close()
    
    

    Java socket的使用

    socket的流程图
    一.发送数据的过程
    在这里插入图片描述
    二.接受数据的过程
    在这里插入图片描述
    Java中socket需要使用到的基本方法

    我们在这里需要先了解到三个方法

    1. getInputStream()这玩意可以得到在网络当中传输的数据流(发送至当前设备的数据,这个时直接在网卡那边获取的)

    2. getOutputStream()这玩意是用来发送的流,将你想要发送的数据发送出去

    3. accept()这玩意是服务端进行接听是否有数据传入的,是否有连接,返回类型为socket

    此外在客户端使用的是socket在服务端使用的是servicesocket

    服务端代码
    这里的话方便做参考就写两个吧,一个是Java的一个是python的
    一java

    
    import java.io.BufferedOutputStream;
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    
    public class EchoServiceDome {
    
    public static void main(String[] args) {
        try {
    
            ServerSocket server = new ServerSocket(6666);
            System.out.println("服务器已启动正在等待客户端连接");
            Socket socket = server.accept();//和python一样时阻塞的 
            System.out.println("客户端连接成功:"+server.getInetAddress().getHostAddress());
            //socke.getInputStream()通过流进行数据传递所以我们那啥可以用这个获取接受
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //读取那个网络的数据
            String info = br.readLine();
            System.out.println(info);
    
            //写入数据,返回给客户端
            PrintStream ps = new PrintStream(new BufferedOutputStream(socket.getOutputStream()));
            ps.println("echo:"+info);
            ps.flush();
            ps.close();
            br.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    
    }
    }
    
    

    二python

        s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        id = socket.gethostbyname(socket.gethostname()).split(":")[0]
        s.connect((id,8089))
        s.send('hello'.encode('utf8'))
        print("数据发送完成")
        tes=s.recv(1024)
        print(tes.decode('utf8'))
        s.close()
    
    

    客户端

    import java.io.BufferedOutputStream;
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintStream;
    import java.net.Socket;
    import java.net.UnknownHostException;
    
    public class EchoClientDome {
        public static void main(String[] args) {
            
            //我们时直接通过字符流来传输的,所以不用和python一样那个是统一转换为了bytes之后我们在解码
            //主要是有用python做了很多封装本质上也是类似的
            try {
                //连接服务器
                Socket  socket = new Socket("localhost",6666);
                PrintStream ps = new PrintStream(new BufferedOutputStream(socket.getOutputStream()));//发送给服务器
                BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));//接手服务器的反馈
    
                ps.println("你好");
                ps.flush();
                //读取,在服务器未发送数据前会处于堵塞状态,也就是会等待服务器相应。
                String info = br.readLine();
                System.out.println(info);
                ps.close();
                br.close();
    
            } catch (UnknownHostException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    
    

    二python

        s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        id = socket.gethostbyname(socket.gethostname()).split(":")[0]
        s.bind((id,8089))
        print("TCP服务器开启")
        s.listen(128)
        data,ip_where=s.accept()
        print(data.recv(1024).decode('utf8'))
        data.send('world'.encode('utf8'))
    
    

    多客户端请求处理

    具体的流程如下图
    在这里插入图片描述
    代码如下:

    import java.io.BufferedOutputStream;
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    
    public class MutilateServiceDome {
        public static void main(String[] args) {
            ExecutorService es = Executors.newFixedThreadPool(4);
            try {
                ServerSocket server = new ServerSocket(6666);
                System.out.println("服务器已开启......");
                while(true){
                    Socket s = server.accept();
                    System.out.println("Host:"+s.getInetAddress().getHostAddress()+"请求访问!");
                    es.execute(new UserDoThread(s));
                }
    
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
    }
    
    class UserDoThread implements Runnable{
        private Socket s;
        private BufferedReader br;
        private PrintStream ps;
        public UserDoThread(Socket s){
            this.s = s;
        }
        public void run(){
            try {
                br = new BufferedReader(new InputStreamReader(s.getInputStream()));
                ps = new PrintStream(new BufferedOutputStream(s.getOutputStream()));
                String info = br.readLine();
                System.out.println(info+"---来自:"+s.getInetAddress().getHostAddress());
                ps.println("echo:"+info);
                ps.flush();
                ps.close();
                br.close();
    
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally{
                ps.flush();
                ps.close();
                try {
                    br.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            
        }
    }
    
    展开全文
  • Java类型转换

    2020-10-01 22:15:55
    因为java是强类型语言,所以要进行有些运算的时候,需要准换为同类型。 运算中,不同类型的数据先转换为同一类型,然后进行运算。 public class Dome4 { public static void main(String[] args) { int i = 128; ...
  • java类型转换

    2020-02-23 00:15:23
    java类型转换 强制转换:(类型)变量名 特点 从高到低 public class Dome1 { public static void main(String[] args) { //单行注释 int i = 128; byte b = (byte)i //-128(存在内存溢出,需要避免) } } 自动...
  • 本篇文章介绍的是利用JAVA poi来实现Java的导出功能。 1、 首先在pom文件中添加相关依赖包: &lt;dependency&gt; &lt;groupId&gt;org.apache.poi&lt;/groupId&gt; &lt;...
  •  File类是File类是java.io包中唯一处理磁盘文件和目录的类。它提供的方法都是与平台无关的, 通过使用File类提供各种方法能够创建、删除文件和目录,或者获取磁盘上指定的文件和目录的相关信息。 1 package ...
  • 1.需要实体类型加上列名注解 package com.mtcanyon.entity; import cn.afterturn.easypoi.excel.annotation.Excel; import lombok.Getter; import lombok.Setter; import lombok.ToString; import org.hibernate....
  • java常用数据类型

    2021-07-10 19:44:46
    java的数据类型分为两大类 基本类型(primitive type) 字节: 位(bit):是计算机内部数据 储存的最小单位,11001100是一个八位二进制数; 字节(byte):是计算机中数据处理的基本单位,习惯上用大写的B来...
  • Java基础数据类型

    2020-10-10 17:33:33
    Java学习笔记(第三篇) Java变量 定义:变量是程序中最基本的存储单元...Java程序中每一个变量都属于特定的数据类型,在使用前必须对其声明,声明格式为: [修饰符] type varName [=value][,varName[=value]……] pub
  • 一、java八种数据类型

    2019-09-21 22:06:42
    java关键字说的简单点就是 是先定义好的,有特殊意义的单词 ,这些关键字 对于 java的便宜 有特殊意义 ,可以 表示数据类型,程序结构等,这些关键字不能当作类名,方法名 ,包名或者参数, 八种基本数据类型的...
  • 1.新建项目(java)JDBCDome 2.新建包(lib) 导入两个JAR (1)连接数据库 (2)测试的JAR@Test 3.新建一个包jdbc.pojo User实体类 public class User{ private Longid; private Str...
  • instanceof和类型转换 instanceof 判断类型是否相似,只要有继承关系,instanceof就为true 例子: //父类 package oop.dome9; public class Person{ public void run(){ System.out.println("run"); } } //子类 ...
  • Java强制类型转换

    2018-05-07 16:10:28
    /*java中的八中基本数据类型 整数: byte、short、int、long 小数: float、double 字符 char 布尔 boolean 字符串的类型:string(引用数据类型)不属于八中基本数据类型 ""记住,双引号引起的都是字符串...
  • 我们知道java中有8中数据类型,而类型转换就是可以把一个值从一种类型转换为另一种类型的过程,比如我们有字符串类型的数据"123",那么我们可以把它转换为一个int类型的数据。 而且从之前的数据类型看,...
  • Day5.java数据类型

    2021-05-29 20:02:35
    java是门强类型语言,要求变量的使用要严格符合规定,所有变量都必须先定义后才能使用 强类型定义语言:强制数据类型定义的语言。也就是说,一旦一个变量被指定了某个数据类型,如果不经过强制转换,那么它就永远是...
  • java: 语言:人与人交流沟通的表达方式 计算机语言:人与计算机之间进行信息交流沟通的一种特殊语言 SUN公司1995年推出 詹姆斯·高斯林 版本: Java SE:标准版,用于桌面应用的开发 桌面应用:UI人机交互 目的...
  • public class dome05 { public static void main(String[] args) { int i=128; byte b=(byte)i;//内存溢出 //强制转换 (类型)变量名 高--低 //自动转换 低--高 System.out.println(i); System.out.printl
  • Java基本数据类型转换

    2021-08-05 15:57:22
    } } 结果 class java.lang.Double class java.lang.Integer 显示转换(强制转换) 当两种数据类型不兼容时,或者目标类型小于原来的类型时无法转换,这是需要强制转换, 浮点型转换成整数型则会省去小数位后的所有数...
  • Java运算中的类型转换

    2021-07-07 21:07:32
    public class Dome04 { public static void main(String[] args) { //int i=128; //byte b=(byte)i;//内存溢出 int i=128; double b=i; //强制转换 (类型)变量名 高--低 //自动转换 低--
  • @JAVA基础语法 JAVA基础语法 提示:本节主要学习二进制,变量,数据类型,运算符。 # 一、变量 ## 什么是变量 变量就是系统为程序分配的一块内存单元,用来存储各种类型的数据。由于该存储单元中的数据可以发生...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,912
精华内容 764
关键字:

dome类型java

java 订阅