筱白to
筱白to

Java 使用 Socket 池 读写 示例

http://blog.csdn.net/z69183787/article/details/23258311

配置文件：

[plain] view plain copy
print ?
  1. host=XXX.XX.XX.XX  
  2. port=8888  
  3. max_size=200  
  4. min_size=30  
host=XXX.XX.XX.XX
port=8888
max_size=200
min_size=30



[java] view plain copy
print ?
  1. package com.wondersgroup.stjt.mail.util;  
  2.   
  3. import java.net.*;  
  4. import java.io.IOException;  
  5. /** 
  6. *  
  7. */  
  8. public class SocketAdapter extends  Socket{  
  9.   /** 
  10.    * 连接状态 
  11.  
  12.    */  
  13.   private boolean status=true;  
  14.   /** 
  15.    * 默认的构造函数 
  16.  
  17.    */  
  18.   public SocketAdapter() {  
  19.     super();  
  20.   }  
  21.   public SocketAdapter(String host,int port)throws UnknownHostException,IOException{  
  22.     super(host,port);  
  23.   }  
  24.   /** 
  25.    * 判断此连接是否空闲 
  26.  
  27.    * @return boolean 空闲返回ture,否则false 
  28.    */  
  29.   public boolean isFree(){  
  30.     return status;  
  31.   }  
  32.   /** 
  33.    * 当使用此连接的时候设置状态为false（忙碌） 
  34.    */  
  35.   public void setBusy(){  
  36.     this.status=false;  
  37.   }  
  38.   /** 
  39.    * 当客户端关闭连接的时候状态设置为true(空闲） 
  40.  
  41.    */  
  42.   @Override  
  43.   public void close()throws IOException{  
  44.    // System.out.println(“Close : set the status is free ”);  
  45.         status=true;  
  46.         super.close();  
  47.   }  
  48.     
  49.   public void destroy() throws IOException{  
  50.     close();  
  51.   
  52.   }  
  53. }  
package com.wondersgroup.stjt.mail.util;

import java.net.*;
import java.io.IOException;
/**
* 
*/
public class SocketAdapter extends  Socket{
  /**
   * 连接状态

   */
  private boolean status=true;
  /**
   * 默认的构造函数

   */
  public SocketAdapter() {
    super();
  }
  public SocketAdapter(String host,int port)throws UnknownHostException,IOException{
    super(host,port);
  }
  /**
   * 判断此连接是否空闲

   * @return boolean 空闲返回ture,否则false
   */
  public boolean isFree(){
    return status;
  }
  /**
   * 当使用此连接的时候设置状态为false（忙碌）
   */
  public void setBusy(){
    this.status=false;
  }
  /**
   * 当客户端关闭连接的时候状态设置为true(空闲）

   */
  @Override
  public void close()throws IOException{
   // System.out.println("Close : set the status is free ");
        status=true;
        super.close();
  }

  public void destroy() throws IOException{
    close();

  }
}


[java] view plain copy
print ?
  1. package com.wondersgroup.stjt.mail.util;  
  2.   
  3. import java.net.*;  
  4. import java.util.*;  
  5. import java.io.IOException;   
  6.   
  7. public interface  
  8.     ConnectionProvider {  
  9.   public static final String SERVER_IP =“host”;  
  10.   public static final String SERVER_PORT = “port”;  
  11.   public static final String MAX_SIZE = “max_size”;  
  12.   public static final String MIN_SIZE = “min_size”;   
  13.   
  14.   /** 
  15.    *判断连接池内是否有连接 
  16.  
  17.    * @return true 有连接返回true,否则返回false 
  18.    */  
  19.   public boolean isPooled();   
  20.   
  21.   /** 
  22.    * 当此方法被调用的时候提供一个 socket 
  23.    * @see Socket 
  24.    * @return Socket a Connection object. 
  25.    */  
  26.   public SocketAdapter getConnection() throws java.net.SocketException;   
  27.   
  28.   /** 
  29.    * 连接池初始化 
  30.    */  
  31.   public void init() throws UnknownHostException, IOException;   
  32.   
  33.   /** 
  34.    * 连接池重新启动 
  35.  
  36.    */  
  37.   public void restart() throws UnknownHostException, IOException;   
  38.   
  39.   /** 
  40.    * 注销连接池 
  41.  
  42.    */  
  43.   public void destroy() throws  IOException;  
  44. }  
package com.wondersgroup.stjt.mail.util;

import java.net.*;
import java.util.*;
import java.io.IOException; 

public interface
    ConnectionProvider {
  public static final String SERVER_IP ="host";
  public static final String SERVER_PORT = "port";
  public static final String MAX_SIZE = "max_size";
  public static final String MIN_SIZE = "min_size"; 

  /**
   *判断连接池内是否有连接

   * @return true 有连接返回true,否则返回false
   */
  public boolean isPooled(); 

  /**
   * 当此方法被调用的时候提供一个 socket
   * @see Socket
   * @return Socket a Connection object.
   */
  public SocketAdapter getConnection() throws java.net.SocketException; 

  /**
   * 连接池初始化
   */
  public void init() throws UnknownHostException, IOException; 

  /**
   * 连接池重新启动

   */
  public void restart() throws UnknownHostException, IOException; 

  /**
   * 注销连接池

   */
  public void destroy() throws  IOException;
}


[java] view plain copy
print ?
  1. package com.wondersgroup.stjt.mail.util;  
  2.   
  3. import java.util.*;  
  4. import java.net.*;  
  5. import java.io.IOException;   
  6.   
  7. /** 
  8. * 
  9. */  
  10. public class MyConnectionProvider  
  11.     implements ConnectionProvider {   
  12.   
  13.   private Properties pro = null;  
  14.   private static ConnectionProvider provider = null;  
  15.   private static Object object_lock = new Object();  
  16.   private static Object[] object_lock_list = new Object[Integer.parseInt(ResourceBundle.getBundle(“mailsocket”).getString(“max_size”))];  
  17.   private String ip;  
  18.   private String port;   
  19.   private static InetSocketAddress inetSockAddr=null;  
  20.   /** 
  21.    * 默认的最大连接数 
  22.    */  
  23.   private int max_size = 20;   
  24.   
  25.   /** 
  26.    * 默认的最小连接数 。。。没用 
  27.  
  28.    */  
  29.   private int min_size = 10;   
  30.   
  31.   /** 
  32.    * Socket connection 
  33.    */  
  34.   private SocketAdapter[] socketpool = null;   
  35.   
  36.   /** 
  37.    * 构造对象的时候初始化连接池 
  38.  
  39.    * @throws UnknownHostException 
  40.    * @throws IOException 
  41.    */  
  42.   private MyConnectionProvider() throws UnknownHostException,  
  43.       IOException {  
  44.       ResourceBundle  res =ResourceBundle.getBundle(”mailsocket”);  
  45.     ip =res.getString(SERVER_IP);  
  46.     port = res.getString(SERVER_PORT);  
  47.     String max_size_s = res.getString(MAX_SIZE);  
  48.     String min_size_s = res.getString(MIN_SIZE);  
  49.     if (max_size_s != null) {  
  50.       max_size = Integer.parseInt(max_size_s);  
  51.     }  
  52.     if (min_size_s != null) {  
  53.       min_size = Integer.parseInt(min_size_s);  
  54.     }   
  55.   
  56.     init(); //构造对象的时候初始化连接池  
  57.   
  58.   }   
  59.   
  60.   /** 
  61.    * 判断是否已经池化 
  62.    * @return boolean 如果池化返回ture,反之返回false 
  63.    */  
  64.   public boolean isPooled() {  
  65.     if (socketpool != null) {  
  66.       return true;  
  67.     }  
  68.     else return false;  
  69.   }   
  70.   
  71.   /** 
  72.    *返回一个连接 
  73.  
  74.    * @return a Connection object. 
  75.  * @throws IOException  
  76.    */  
  77.   public SocketAdapter getConnection()  {  
  78.       SocketAdapter s = null;  
  79.       //System.out.println(“loop”);  
  80.     for (int i = 0; i < socketpool.length; i++) {  
  81.         //System.out.println(“loop detail i=”+i);  
  82.       if (socketpool[i] != null) {  
  83.         //如果有空闲的连接，返回一个空闲连接，如果没有，继续循环  
  84.   
  85.           if(!socketpool[i].isFree()){  
  86.               continue;  
  87.             }else{  
  88.                 synchronized (object_lock_list[i]){  
  89.                  if (socketpool[i].isFree()) {  
  90.                   s = socketpool[i];  
  91.                    
  92.                  // System.out.println(i+” socket isConnected()=”+s.isConnected()+” binding”+s.isBound());  
  93.                   try {  
  94.                       s=socketpool[i]=new SocketAdapter(ip, Integer.parseInt(port));  
  95.                     socketpool[i].setBusy();  
  96.                     // System.out.println(“socket”+i);  
  97.                   } catch (IOException e) {  
  98.   
  99.                       e.printStackTrace();  
  100.                       return null;  
  101.                   }  
  102.                   return s;  
  103.                  }else{  
  104.                      continue;  
  105.                  }  
  106.                 }  
  107.             }  
  108.            
  109.           
  110.       }  
  111.       else { //如果连接为空，证明超过最小连接数，重新生成连接  
  112.   
  113.         try {  
  114.             System.out.println(”new socket”+i);  
  115.           s = socketpool[i] = new SocketAdapter(ip, Integer.parseInt(port));  
  116.           return s;  
  117.         }  
  118.         catch (Exception e) {  
  119.           //never throw  
  120.             return null;  
  121.         }  
  122.       }  
  123.     }  
  124.     return s;  
  125.   }   
  126.   
  127.   /** 
  128.    * 初始化连接池 
  129.    * @throws UnknownHostException  
  130.    * @throws IOException  
  131.    */  
  132.   public void init() throws UnknownHostException, IOException {   
  133.   
  134.     socketpool = new SocketAdapter[max_size];  
  135.   
  136.     for (int i = 0; i < max_size; i++) {  
  137.         object_lock_list[i]=new Object();  
  138.       }  
  139.     
  140.     System.out.println(”System init success ….”);  
  141.   }   
  142.   
  143.   /** 
  144.    * 重新启动连接池 
  145.  
  146.    * @throws UnknownHostException 
  147.    * @throws IOException 
  148.    */  
  149.   public void restart() throws UnknownHostException, IOException {  
  150.   destroy();  
  151.   init();  
  152.   }   
  153.   
  154.   /** 
  155.    * 注销此连接池 
  156.  * @throws IOException  
  157.    */  
  158.   public void destroy() throws IOException {  
  159.     for (int i = 0; i < socketpool.length; i++) {  
  160.       if (socketpool[i] != null) {  
  161.         SocketAdapter adapter = (SocketAdapter) socketpool[i];  
  162.         adapter.destroy();  
  163.         //System.out.print(“” );  
  164.       }  
  165.     }  
  166.     System.out.println(”\ndestory success ….”);  
  167.   }  
  168.   /** 
  169.    * 生成此连接池实现的对象 
  170.  
  171.    * @throws UnknownHostException 
  172.    * @throws IOException  
  173.    * @return ConnectionProvider  
  174.    */  
  175.   public static ConnectionProvider newInstance() throws  
  176.       UnknownHostException, IOException {  
  177.     if (provider == null) {  
  178.       synchronized (object_lock) {  
  179.         if (provider == null) {  
  180.           provider = new MyConnectionProvider();  
  181.         }  
  182.       }  
  183.     }  
  184.     return provider;  
  185.   }  
  186. /** 
  187.  * 读取properties文件。 
  188.  
  189.  * @param key 
  190.  * @param properName 
  191.  * @return 
  192.  */  
  193.   public static String readProperties(String key, String properName) {  
  194.         ResourceBundle rsrc = null;  
  195.         String value = ”“;  
  196.         rsrc = ResourceBundle.getBundle(properName);  
  197.         value = rsrc.getString(key);  
  198.         return value;  
  199.   
  200.     }  
  201. }  
package com.wondersgroup.stjt.mail.util;

import java.util.*;
import java.net.*;
import java.io.IOException; 

/**
*
*/
public class MyConnectionProvider
    implements ConnectionProvider { 

  private Properties pro = null;
  private static ConnectionProvider provider = null;
  private static Object object_lock = new Object();
  private static Object[] object_lock_list = new Object[Integer.parseInt(ResourceBundle.getBundle("mailsocket").getString("max_size"))];
  private String ip;
  private String port; 
  private static InetSocketAddress inetSockAddr=null;
  /**
   * 默认的最大连接数
   */
  private int max_size = 20; 

  /**
   * 默认的最小连接数 。。。没用

   */
  private int min_size = 10; 

  /**
   * Socket connection
   */
  private SocketAdapter[] socketpool = null; 

  /**
   * 构造对象的时候初始化连接池

   * @throws UnknownHostException
   * @throws IOException
   */
  private MyConnectionProvider() throws UnknownHostException,
      IOException {
      ResourceBundle  res =ResourceBundle.getBundle("mailsocket");
    ip =res.getString(SERVER_IP);
    port = res.getString(SERVER_PORT);
    String max_size_s = res.getString(MAX_SIZE);
    String min_size_s = res.getString(MIN_SIZE);
    if (max_size_s != null) {
      max_size = Integer.parseInt(max_size_s);
    }
    if (min_size_s != null) {
      min_size = Integer.parseInt(min_size_s);
    } 

    init(); //构造对象的时候初始化连接池

  } 

  /**
   * 判断是否已经池化
   * @return boolean 如果池化返回ture,反之返回false
   */
  public boolean isPooled() {
    if (socketpool != null) {
      return true;
    }
    else return false;
  } 

  /**
   *返回一个连接

   * @return a Connection object.
 * @throws IOException 
   */
  public SocketAdapter getConnection()  {
      SocketAdapter s = null;
      //System.out.println("loop");
    for (int i = 0; i < socketpool.length; i++) {
        //System.out.println("loop detail i="+i);
      if (socketpool[i] != null) {
        //如果有空闲的连接，返回一个空闲连接，如果没有，继续循环

          if(!socketpool[i].isFree()){
              continue;
            }else{
                synchronized (object_lock_list[i]){
                 if (socketpool[i].isFree()) {
                  s = socketpool[i];

                 // System.out.println(i+" socket isConnected()="+s.isConnected()+" binding"+s.isBound());
                  try {
                      s=socketpool[i]=new SocketAdapter(ip, Integer.parseInt(port));
                    socketpool[i].setBusy();
                    // System.out.println("socket"+i);
                  } catch (IOException e) {

                      e.printStackTrace();
                      return null;
                  }
                  return s;
                 }else{
                     continue;
                 }
                }
            }


      }
      else { //如果连接为空，证明超过最小连接数，重新生成连接

        try {
            System.out.println("new socket"+i);
          s = socketpool[i] = new SocketAdapter(ip, Integer.parseInt(port));
          return s;
        }
        catch (Exception e) {
          //never throw
            return null;
        }
      }
    }
    return s;
  } 

  /**
   * 初始化连接池
   * @throws UnknownHostException 
   * @throws IOException 
   */
  public void init() throws UnknownHostException, IOException { 

    socketpool = new SocketAdapter[max_size];

    for (int i = 0; i < max_size; i++) {
        object_lock_list[i]=new Object();
      }

    System.out.println("System init success ....");
  } 

  /**
   * 重新启动连接池

   * @throws UnknownHostException
   * @throws IOException
   */
  public void restart() throws UnknownHostException, IOException {
  destroy();
  init();
  } 

  /**
   * 注销此连接池
 * @throws IOException 
   */
  public void destroy() throws IOException {
    for (int i = 0; i < socketpool.length; i++) {
      if (socketpool[i] != null) {
        SocketAdapter adapter = (SocketAdapter) socketpool[i];
        adapter.destroy();
        //System.out.print("" );
      }
    }
    System.out.println("\ndestory success ....");
  }
  /**
   * 生成此连接池实现的对象

   * @throws UnknownHostException
   * @throws IOException 
   * @return ConnectionProvider 
   */
  public static ConnectionProvider newInstance() throws
      UnknownHostException, IOException {
    if (provider == null) {
      synchronized (object_lock) {
        if (provider == null) {
          provider = new MyConnectionProvider();
        }
      }
    }
    return provider;
  }
/**
 * 读取properties文件。

 * @param key
 * @param properName
 * @return
 */
  public static String readProperties(String key, String properName) {
        ResourceBundle rsrc = null;
        String value = "";
        rsrc = ResourceBundle.getBundle(properName);
        value = rsrc.getString(key);
        return value;

    }
}


Main

[java] view plain copy
print ?
  1. package com.wondersgroup.stjt.mail.action;  
  2.   
  3. import java.io.BufferedReader;  
  4. import java.io.FileInputStream;  
  5. import java.io.FileNotFoundException;  
  6. import java.io.IOException;  
  7. import java.io.InputStreamReader;  
  8. import java.io.PrintWriter;  
  9. import java.net.InetAddress;  
  10. import java.net.InetSocketAddress;  
  11. import java.net.Socket;  
  12. import java.net.SocketAddress;  
  13. import java.net.UnknownHostException;  
  14. import java.sql.ResultSet;  
  15. import java.sql.SQLException;  
  16. import java.util.Properties;  
  17. import java.util.ResourceBundle;  
  18.   
  19.   
  20. import com.wondersgroup.framework.core.web.action.xwork.AbstractAjaxAction;  
  21. import com.wondersgroup.module.common.ExecuteSql;  
  22. import com.wondersgroup.stjt.util.StringUtil;  
  23. import com.wondersgroup.stjt.mail.util.*;  
  24.   
  25. public class ShmetromailAction extends AbstractAjaxAction {  
  26.     //private String emailDomain = ”@shmetro.com”;  
  27.     //private String host = “222.66.3.199”;  
  28.     //private int port = 8888;  
  29.     private String errMsg = “-“;  
  30.     private String okMsg = “+”;  
  31.   
  32.     public String getMailDetail() throws UnknownHostException {  
  33.           
  34.         //获得用户名  
  35.   
  36.         String curLoginName = (String) this.getRequest().getSession()  
  37.                 .getAttribute(”login_name”);  
  38.         String mailLoginName = ”“;  
  39.         String mailPwd = ”“;  
  40.   
  41.         //取得用户email地址和email密码！  
  42.   
  43.         ExecuteSql dealsql = new ExecuteSql();  
  44.         String sql = ”select t.id,t.email from cs_user t where t.login_name=’”+curLoginName+“’”;  
  45.         //System.out.println(“sql”);  
  46.         //dealsql.ExecuteSql(sql);  
  47.         //String mailLoginName=”“;  
  48.         int iuserid=0;  
  49.         //String mailPwd=”“;  
  50.         try{  
  51.             ResultSet rs = dealsql.ExecuteDemandSql(sql);  
  52.               
  53.             if(rs.next()){  
  54.                  iuserid = rs.getInt(”ID”);  
  55.                  mailLoginName=rs.getString(”EMAIL”);  
  56.                 //System.out.println(iuserid+”—-“+mailLoginName);  
  57.             }  
  58.             sql=”select t.email_passwd from t_cs_user t where t.id=’”+iuserid+“’”;  
  59.              rs = dealsql.ExecuteDemandSql(sql);  
  60.              if(rs.next()){  
  61.                   
  62.                  mailPwd=rs.getString(”email_passwd”);  
  63.                 //System.out.println(iuserid+”–++–”+mailPwd);  
  64.             }  
  65.              rs.close();  
  66.         }catch(Exception e){  
  67.             e.printStackTrace();  
  68.             createJSonData(”{\”success\”:false, \”results\”: \”connectionerr\”}”);  
  69.             return AJAX;  
  70.         }finally{  
  71.               
  72.             try {  
  73.                 dealsql.close();  
  74.             } catch (SQLException e) {  
  75.                   
  76.                 e.printStackTrace();  
  77.                 createJSonData(”{\”success\”:false, \”results\”: \”connectionerr\”}”);  
  78.                 return AJAX;  
  79.             }  
  80.         }  
  81.           
  82.         //判断地址，密码和发性  
  83.   
  84.         //Socket connection=null;  
  85.         if(StringUtil.isNull(mailLoginName)||!mailLoginName.matches(“\\S+@shmetro\\.com”)||StringUtil.isNull(mailPwd)){  
  86.             createJSonData(”{\”success\”:false, \”results\”: \”errgetemailifo\”}”);  
  87.             return AJAX;  
  88.         }  
  89.         SocketAdapter connection = null;  
  90.         int allMailCount=0;  
  91.         int unReadCount=0;  
  92.         // connect to server  
  93.         try {  
  94.             //获取新的connection   
  95.             ConnectionProvider conpool=MyConnectionProvider.newInstance();  
  96.               
  97.             connection=conpool.getConnection();  
  98.               
  99.             if(connection==null){  
  100.                 createJSonData(”{\”success\”:false, \”results\”: \”errgetconnection\”}”);  
  101.                 return AJAX;  
  102.             }  
  103.             //so1.setKeepAlive(true);  
  104.             //connection=so1;  
  105.               
  106.             BufferedReader input = new BufferedReader(new InputStreamReader(  
  107.                     connection.getInputStream()));// 接受  
  108.             PrintWriter out = new PrintWriter(connection.getOutputStream(),  
  109.                     true/* autoFlush */);// 传输  
  110.   
  111.               
  112.             String info = null;// 接受信息  
  113.             // read information from server  
  114.             info = input.readLine();  
  115.               
  116.             //输入邮件地址，密码  
  117.   
  118.             BufferedReader in = new BufferedReader(new InputStreamReader(System.in));  
  119.             String sInput =null;  
  120.             String line = null;  
  121.             out.println(”USER ” + mailLoginName);  
  122.             System.out.println(”USER ” + mailLoginName);  
  123.             out.flush();  
  124.             line = input.readLine();  
  125.             System.out.println(”line ” + line);  
  126.             if(StringUtil.isNull(line)||line.startsWith(errMsg)){  
  127.                 createJSonData(”{\”success\”:false, \”results\”: \”errloginname\”}”);  
  128.                 return AJAX;  
  129.             }  
  130.             //System.out.println(“1”+line);  
  131.             out.println(”PASS ” + mailPwd);  
  132.             out.flush();  
  133.             line = input.readLine();  
  134.             //System.out.println(“line2 ” + line);  
  135.             if(StringUtil.isNull(line)||line.startsWith(errMsg)){  
  136.                 createJSonData(”{\”success\”:false, \”results\”: \”errpwd\”}”);  
  137.                 return AJAX;  
  138.             }  
  139.             //System.out.println(“2”+line);  
  140.             //进入目录查找邮件信息。  
  141.   
  142.             out.println(”CHDIR inbox”);  
  143.             line = input.readLine();  
  144.             if(StringUtil.isNull(line)||line.startsWith(errMsg)){  
  145.                 createJSonData(”{\”success\”:false, \”results\”: \”errchdir\”}”);  
  146.                 return AJAX;  
  147.             }  
  148.             //System.out.println(“3”+line);  
  149.             out.println(”LIST”);  
  150.             line = input.readLine();  
  151.             if(StringUtil.isNull(line)||line.startsWith(errMsg)){  
  152.                 createJSonData(”{\”success\”:false, \”results\”: \”errchdir\”}”);  
  153.                 return AJAX;  
  154.             }  
  155.             int i=0;  
  156.             //获取邮件信息并统计  
  157.   
  158.             while((line = input.readLine()) != null){  
  159.                 //System.out.println(i++);  
  160.                 int temp=getMailInfo(line);  
  161.                 if(temp!=-1){  
  162.                     if(temp!=-2){  
  163.                         allMailCount++;  
  164.                         if(temp==0){  
  165.                             unReadCount++;  
  166.                         }  
  167.                     }else{  
  168.                           
  169.                         break;  
  170.                     }  
  171.                 }else{  
  172.                     createJSonData(”{\”success\”:false, \”results\”: \”errmailinfo\”}”);  
  173.                     return AJAX;  
  174.                 }  
  175.                 //System.out.println(line);  
  176.             }  
  177.             //System.out.println(allMailCount+”—-“+unReadCount);  
  178.   
  179.         } catch (UnknownHostException e) {  
  180.             // TODO Auto-generated catch block  
  181.             e.printStackTrace();  
  182.   
  183.         } catch (IOException e) {  
  184.             // TODO Auto-generated catch block  
  185.             e.printStackTrace();  
  186.   
  187.         } finally {  
  188.             if (connection != null)  
  189.                 try {  
  190.                     connection.close();  
  191.                 } catch (Exception e) {  
  192.                     // TODO Auto-generated catch block  
  193.                     e.printStackTrace();  
  194.                 }  
  195.         }  
  196.         //返回。  
  197.   
  198.         createJSonData(”{\”success\”:true, \”results\”:{\”allMailCount\”: \”“+allMailCount+“\”, \”unReadCount\”: \”“+unReadCount+“\”}}”);  
  199.         return AJAX;  
  200.     }  
  201.     private static int getMailInfo(String line) {  
  202.         if(line.matches(“\\S+\\s+\\S+\\s+\\d+”)){  
  203.             String re=line.split(”\\s+”)[2];  
  204.             return Integer.parseInt(re);  
  205.         }  
  206.         //System.out.println(“===”+line+”===”);  
  207.         if(line.matches(“.”)){  
  208.             //System.out.println(“yes”);  
  209.             return -2;  
  210.         }  
  211.         return -1;  
  212.     }  
  213. public static void main(String[] args) throws IOException{  
  214.     String errMsg = ”-“;  
  215.     String okMsg = ”+”;  
  216.     String mailLoginName = ”[email protected]”;  
  217.     String mailPwd = ”1111”;  
  218.       
  219.     SocketAdapter connection = null;  
  220.     int allMailCount=0;  
  221.         int unReadCount=0;  
  222.     // connect to server  
  223.     try {  
  224.         //获取新的connection   
  225.         ConnectionProvider conpool=MyConnectionProvider.newInstance();  
  226.           
  227.         connection=conpool.getConnection();  
  228.           
  229.         if(connection==null){  
  230.           
  231.         }  
  232.         //so1.setKeepAlive(true);  
  233.         //connection=so1;  
  234.           
  235.         BufferedReader input = new BufferedReader(new InputStreamReader(  
  236.                 connection.getInputStream()));// 接受  
  237.         PrintWriter out = new PrintWriter(connection.getOutputStream(),  
  238.                 true/* autoFlush */);// 传输  
  239.   
  240.           
  241.         String info = null;// 接受信息  
  242.         // read information from server  
  243.         //info = input.readLine();  
  244.           
  245.         //输入邮件地址，密码  
  246.   
  247.         //BufferedReader in = new BufferedReader(new InputStreamReader(System.in));  
  248.         String sInput =null;  
  249.         String line = null;  
  250.         out.println(”USER ” + mailLoginName);  
  251.         System.out.println(”USER ” + mailLoginName);  
  252.         out.flush();  
  253.         line = input.readLine();  
  254.         System.out.println(”line ” + line);  
  255.         if(StringUtil.isNull(line)||line.startsWith(errMsg)){  
  256.               
  257.         }  
  258.         //System.out.println(“1”+line);  
  259.         out.println(”PASS ” + mailPwd);  
  260.         out.flush();  
  261.         line = input.readLine();  
  262.         //System.out.println(“line2 ” + line);  
  263.         if(StringUtil.isNull(line)||line.startsWith(errMsg)){  
  264.               
  265.         }  
  266.         //System.out.println(“2”+line);  
  267.         //进入目录查找邮件信息。  
  268.   
  269.         out.println(”CHDIR inbox”);  
  270.         line = input.readLine();  
  271.         if(StringUtil.isNull(line)||line.startsWith(errMsg)){  
  272.               
  273.         }  
  274.         //System.out.println(“3”+line);  
  275.         out.println(”LIST”);  
  276.         line = input.readLine();  
  277.         if(StringUtil.isNull(line)||line.startsWith(errMsg)){  
  278.               
  279.         }  
  280.         int i=0;  
  281.         //获取邮件信息并统计  
  282.   
  283.         while((line = input.readLine()) != null){  
  284.             //System.out.println(i++);  
  285.             int temp=getMailInfo(line);  
  286.             if(temp!=-1){  
  287.                 if(temp!=-2){  
  288.                     allMailCount++;  
  289.                     if(temp==0){  
  290.                         unReadCount++;  
  291.                     }  
  292.                 }else{  
  293.                       
  294.                     break;  
  295.                 }  
  296.             }else{  
  297.               
  298.             }  
  299.             //System.out.println(line);  
  300.         }  
  301.         //System.out.println(allMailCount+”—-“+unReadCount);  
  302.   
  303.     } catch (UnknownHostException e) {  
  304.         // TODO Auto-generated catch block  
  305.         e.printStackTrace();  
  306.   
  307.     } catch (IOException e) {  
  308.         // TODO Auto-generated catch block  
  309.         e.printStackTrace();  
  310.         System.out.println(”111111111111111111111111111111111111111”);  
  311.     } finally {  
  312.         if (connection != null)  
  313.             try {  
  314.                 connection.close();  
  315.             } catch (Exception e) {  
  316.                 // TODO Auto-generated catch block  
  317.                 e.printStackTrace();  
  318.             }  
  319.     }  
  320.   
  321.   }  
  322.   
  323. }  
package com.wondersgroup.stjt.mail.action;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.UnknownHostException;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;
import java.util.ResourceBundle;


import com.wondersgroup.framework.core.web.action.xwork.AbstractAjaxAction;
import com.wondersgroup.module.common.ExecuteSql;
import com.wondersgroup.stjt.util.StringUtil;
import com.wondersgroup.stjt.mail.util.*;

public class ShmetromailAction extends AbstractAjaxAction {
    //private String emailDomain = "@shmetro.com";
    //private String host = "222.66.3.199";
    //private int port = 8888;
    private String errMsg = "-";
    private String okMsg = "+";

    public String getMailDetail() throws UnknownHostException {

        //获得用户名

        String curLoginName = (String) this.getRequest().getSession()
                .getAttribute("login_name");
        String mailLoginName = "";
        String mailPwd = "";

        //取得用户email地址和email密码！

        ExecuteSql dealsql = new ExecuteSql();
        String sql = "select t.id,t.email from cs_user t where t.login_name='"+curLoginName+"'";
        //System.out.println("sql");
        //dealsql.ExecuteSql(sql);
        //String mailLoginName="";
        int iuserid=0;
        //String mailPwd="";
        try{
            ResultSet rs = dealsql.ExecuteDemandSql(sql);

            if(rs.next()){
                 iuserid = rs.getInt("ID");
                 mailLoginName=rs.getString("EMAIL");
                //System.out.println(iuserid+"----"+mailLoginName);
            }
            sql="select t.email_passwd from t_cs_user t where t.id='"+iuserid+"'";
             rs = dealsql.ExecuteDemandSql(sql);
             if(rs.next()){

                 mailPwd=rs.getString("email_passwd");
                //System.out.println(iuserid+"--++--"+mailPwd);
            }
             rs.close();
        }catch(Exception e){
            e.printStackTrace();
            createJSonData("{\"success\":false, \"results\": \"connectionerr\"}");
            return AJAX;
        }finally{

            try {
                dealsql.close();
            } catch (SQLException e) {

                e.printStackTrace();
                createJSonData("{\"success\":false, \"results\": \"connectionerr\"}");
                return AJAX;
            }
        }

        //判断地址，密码和发性

        //Socket connection=null;
        if(StringUtil.isNull(mailLoginName)||!mailLoginName.matches("\\S+@shmetro\\.com")||StringUtil.isNull(mailPwd)){
            createJSonData("{\"success\":false, \"results\": \"errgetemailifo\"}");
            return AJAX;
        }
        SocketAdapter connection = null;
        int allMailCount=0;
        int unReadCount=0;
        // connect to server
        try {
            //获取新的connection 
            ConnectionProvider conpool=MyConnectionProvider.newInstance();

            connection=conpool.getConnection();

            if(connection==null){
                createJSonData("{\"success\":false, \"results\": \"errgetconnection\"}");
                return AJAX;
            }
            //so1.setKeepAlive(true);
            //connection=so1;

            BufferedReader input = new BufferedReader(new InputStreamReader(
                    connection.getInputStream()));// 接受
            PrintWriter out = new PrintWriter(connection.getOutputStream(),
                    true/* autoFlush */);// 传输


            String info = null;// 接受信息
            // read information from server
            info = input.readLine();

            //输入邮件地址，密码

            BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
            String sInput =null;
            String line = null;
            out.println("USER " + mailLoginName);
            System.out.println("USER " + mailLoginName);
            out.flush();
            line = input.readLine();
            System.out.println("line " + line);
            if(StringUtil.isNull(line)||line.startsWith(errMsg)){
                createJSonData("{\"success\":false, \"results\": \"errloginname\"}");
                return AJAX;
            }
            //System.out.println("1"+line);
            out.println("PASS " + mailPwd);
            out.flush();
            line = input.readLine();
            //System.out.println("line2 " + line);
            if(StringUtil.isNull(line)||line.startsWith(errMsg)){
                createJSonData("{\"success\":false, \"results\": \"errpwd\"}");
                return AJAX;
            }
            //System.out.println("2"+line);
            //进入目录查找邮件信息。

            out.println("CHDIR inbox");
            line = input.readLine();
            if(StringUtil.isNull(line)||line.startsWith(errMsg)){
                createJSonData("{\"success\":false, \"results\": \"errchdir\"}");
                return AJAX;
            }
            //System.out.println("3"+line);
            out.println("LIST");
            line = input.readLine();
            if(StringUtil.isNull(line)||line.startsWith(errMsg)){
                createJSonData("{\"success\":false, \"results\": \"errchdir\"}");
                return AJAX;
            }
            int i=0;
            //获取邮件信息并统计

            while((line = input.readLine()) != null){
                //System.out.println(i++);
                int temp=getMailInfo(line);
                if(temp!=-1){
                    if(temp!=-2){
                        allMailCount++;
                        if(temp==0){
                            unReadCount++;
                        }
                    }else{

                        break;
                    }
                }else{
                    createJSonData("{\"success\":false, \"results\": \"errmailinfo\"}");
                    return AJAX;
                }
                //System.out.println(line);
            }
            //System.out.println(allMailCount+"----"+unReadCount);

        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();

        } finally {
            if (connection != null)
                try {
                    connection.close();
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
        }
        //返回。

        createJSonData("{\"success\":true, \"results\":{\"allMailCount\": \""+allMailCount+"\", \"unReadCount\": \""+unReadCount+"\"}}");
        return AJAX;
    }
    private static int getMailInfo(String line) {
        if(line.matches("\\S+\\s+\\S+\\s+\\d+")){
            String re=line.split("\\s+")[2];
            return Integer.parseInt(re);
        }
        //System.out.println("==="+line+"===");
        if(line.matches(".")){
            //System.out.println("yes");
            return -2;
        }
        return -1;
    }
public static void main(String[] args) throws IOException{
    String errMsg = "-";
    String okMsg = "+";
    String mailLoginName = "[email protected]";
    String mailPwd = "1111";

    SocketAdapter connection = null;
    int allMailCount=0;
        int unReadCount=0;
    // connect to server
    try {
        //获取新的connection 
        ConnectionProvider conpool=MyConnectionProvider.newInstance();

        connection=conpool.getConnection();

        if(connection==null){

        }
        //so1.setKeepAlive(true);
        //connection=so1;

        BufferedReader input = new BufferedReader(new InputStreamReader(
                connection.getInputStream()));// 接受
        PrintWriter out = new PrintWriter(connection.getOutputStream(),
                true/* autoFlush */);// 传输


        String info = null;// 接受信息
        // read information from server
        //info = input.readLine();

        //输入邮件地址，密码

        //BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String sInput =null;
        String line = null;
        out.println("USER " + mailLoginName);
        System.out.println("USER " + mailLoginName);
        out.flush();
        line = input.readLine();
        System.out.println("line " + line);
        if(StringUtil.isNull(line)||line.startsWith(errMsg)){

        }
        //System.out.println("1"+line);
        out.println("PASS " + mailPwd);
        out.flush();
        line = input.readLine();
        //System.out.println("line2 " + line);
        if(StringUtil.isNull(line)||line.startsWith(errMsg)){

        }
        //System.out.println("2"+line);
        //进入目录查找邮件信息。

        out.println("CHDIR inbox");
        line = input.readLine();
        if(StringUtil.isNull(line)||line.startsWith(errMsg)){

        }
        //System.out.println("3"+line);
        out.println("LIST");
        line = input.readLine();
        if(StringUtil.isNull(line)||line.startsWith(errMsg)){

        }
        int i=0;
        //获取邮件信息并统计

        while((line = input.readLine()) != null){
            //System.out.println(i++);
            int temp=getMailInfo(line);
            if(temp!=-1){
                if(temp!=-2){
                    allMailCount++;
                    if(temp==0){
                        unReadCount++;
                    }
                }else{

                    break;
                }
            }else{

            }
            //System.out.println(line);
        }
        //System.out.println(allMailCount+"----"+unReadCount);

    } catch (UnknownHostException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();

    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
        System.out.println("111111111111111111111111111111111111111");
    } finally {
        if (connection != null)
            try {
                connection.close();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    }

  }

}


你可能感兴趣的:(socket,socket,java)

  • AI 驱动的智慧大脑：打造企业动态知识库，开启高效管理新时代 网罗开发 人工智能AI大模型深度学习人工智能
    网罗开发（小红书、快手、视频号同名）  大家好，我是展菲，目前在上市企业从事人工智能项目研发管理工作，平时热衷于分享各种编程领域的软硬技能知识以及前沿技术，包括iOS、前端、HarmonyOS、Java、Python等方向。在移动端开发、鸿蒙开发、物联网、嵌入式、云原生、开源等领域有深厚造诣。图书作者：《ESP32-C3物联网工程开发实战》图书作者：《SwiftUI入门，进阶与实战》超级个体：CO
  • 使用 Java 更新 Word 文档中的图表数据-超详细 Ben_F javaword开发语言
    使用Java更新Word文档中的图表数据在日常的工作中，尤其是在数据分析和报告自动化的场景中，可能会遇到需要定期更新Word文档中的图表数据的需求。比如，生成数据报告时，我们需要在图表中更新一些动态的数据值。今天，我将展示如何使用Java和ApachePOI库来实现这一功能：自动读取Word文件中的图表，提取Excel数据源，修改数据并更新图表。背景我们要处理的是Word文档中的图表，而这些图表的
  • SSL/TLS 协议、SSL证书 和 SSH协议 的区别和联系 小丁学Java 计算机网络sslssh网络协议
    下面是SSL/TLS协议、SSL证书和SSH协议的区别和联系，包含它们的英文全称和中文全称：属性SSL/TLS协议SSL证书SSH协议英文全称SecureSocketsLayer/TransportLayerSecuritySecureSocketsLayerCertificateSecureShellProtocol中文全称安全套接字层/传输层安全协议安全套接字层证书安全外壳协议定义SSL/TL
  • Node.js学习01-初识Node.js与内置模块 Meowmow nodejsnode.js学习javascript
    目录初识Node.js在Node.js环境执行js代码内置模块fs文件系统模块路径动态拼接问题path路径模块http模块request请求对象初识Node.jsNode.js是基于ChromeV8引擎的JavaScript运行环境，无法调用DOM和BOM等浏览器内置API。使用Node.js可以：基于Express框架快速搭建web应用基于Electron框架构建跨平台的桌面应用基于restif
  • UnsatisfiedDependencyException 薄辉 javaspringmybatisservletspringboot
    UnsatisfiedDependencyException是一种Java异常，通常表示在进行依赖注入时出现了问题。这种异常通常发生在Spring框架中，当Spring在创建Bean实例时，无法找到某个依赖项所对应的Bean时就会抛出此异常。依赖注入是一种设计模式，它允许一个类将其依赖项(即需要的其他对象)从外部注入进来，而不是自己创建或查找这些依赖项。这样可以让类更加灵活，并且可以更容易地测试它
  • 使用Windows系统进行Node.js离线安装 YOUFDJ windowsnode.js编程
    Node.js是一个基于ChromeV8引擎的JavaScript运行时，广泛用于服务器端开发。通常情况下，我们可以通过官方网站下载安装程序进行Node.js的安装，但有时候在没有网络连接的情况下，我们需要进行离线安装。本文将详细介绍如何在Windows系统下进行Node.js的离线安装。以下是进行Node.js离线安装的步骤：第一步：下载Node.js安装包首先，我们需要从官方网站或其他可信来源
  • 【MySQL篇】使用Java操作MySQL实现数据交互 m0_74825260 面试阿里巴巴mysqljava交互
    目录JDBC的认识：安装MySQL驱动包：下载完成后将包导入IDEA实现代码：1.创建数据源2.和数据库服务器建立连接?3.构造操作数据库的sql语句.4.执行SQL语句5.释放资源?完整代码：Insert：Select：Update：JDBC的认识：JDBC，即JavaDatabaseConnectivity，java数据库连接。是一种用于执行SQL语句的JavaAPI，它是Java中的数据库连
  • 【问题解决】org.springframework.web.util.NestedServletException Handler dispatch failed； m0_74825260 面试学习路线阿里巴巴前端
    详细异常信息：org.springframework.web.util.NestedServletException:Handlerdispatchfailed;nestedexceptionisjava.lang.NoClassDefFoundError:javax/xml/bind/DatatypeConverteratorg.springframework.web.servlet.Dispa
  • netty 与 websocket JIU_WW websocket网络协议网络nettyjava
    目录1.Netty简介2.WebSocket简介3.Netty与WebSocket的关系3.1Netty对WebSocket的支持3.2两者的层级关系3.3常见误解澄清4.Netty的通用性体现4.1多协议支持4.2非WebSocket应用示5.选择Netty实现WebSocket的优势6.总结1.Netty简介Netty是一个高性能、异步事件驱动的网络应用框架，专为开发可扩展和高性能的服务器与客
  • Android存储（读取）之SD卡 2501_90225911 android
    packagecom.github.c.ceshi;importandroid.content.Context;importandroid.os.Environment;importandroid.widget.Toast;importjava.io.BufferedReader;importjava.io.File;importjava.io.FileInputStream;importjava
  • 【Camrea2录制视频报错问题修复java.lang.IllegalArgumentException: Surface was abandoned】 weixin_37659322 音视频java开发语言
    问题现象修改后的代码在机器正常intrecordTime=10*60*1000;try{FilevedioTempPath=newFile(Environment.getExternalStorageDirectory().getAbsolutePath()+"/video/temp/");if(!vedioTempPath.exists()){vedioTempPath.mkdirs();}ve
  • 基于QT的电子木鱼小游戏(C/C++) 今天你debug了嘛？ qtqtc语言c++
    文章目录前言今年最火爆的解压小游戏电子木鱼，现在许多软件都上架了这个小程序。我在网上看了一下基本上都是用py和Java写的，所以我用QT重新写了一下，作为小白练手项目非常适合一、界面展示二、功能模块1)木鱼缩放2)功德+1显示3)音乐4)自动5)延时6)完整代码前言今年最火爆的解压小游戏电子木鱼，现在许多软件都上架了这个小程序。我在网上看了一下基本上都是用py和Java写的，所以我用QT重新写了一
  • 【Android】Android Studio 中文乱码问题解决方案 非晓为骁 Androidandroidandroidstudioide
    问题现象在Java文件编译或运行时，IDE控制台或代码编辑区出现类似以下乱码提示：E:\...\FileHelper.java:92:����:�Ҳ�������此类乱码通常由编码配置冲突或文件存储格式异常导致。核心解决步骤1.统一编码配置全局设置进入File→Settings→Editor→FileEncodings，确保以下三项均设置为UTF-8：GlobalEncoding、ProjectE
  • 字节跳动 后端开发 一面 面经 我喝AD钙 面经java后端面试
    2023-08-07字节跳动后端开发一面1自我介绍：学历背景-实习/项目-校园经历-获奖2介绍一下java全栈实习：业务-解决方案-工作-成果-反思3xx功能怎么做的：业务-表设计-前端原型-功能-前后端接口-后端实现4订单管理货物管理怎么做的：xxx5数据存储用的啥：mysql给主键常用字段加索引6货物限量怎么处理：java加锁（锁的比较与选择）/数据库事务（考虑了吗，为什么没用）7单体应用，某
  • 使用Kettle定时同步数据库的数据（详细实例操作） 故里2130 包教会专栏数据库
    数据库的数据同步、迁移在我们运维软件中，经常使用，而且非常的频繁。同步、迁移数据的工具非常多，比如Navicat、SqlServer等等，甚至很多公司，都是自己写的定时同步软件。今天，我们介绍一款Java开源免费的数据库同步软件，功能非常强大。本节只演示，定时同步数据库的数据，从test数据库定时同步到test1数据库的教程。（坑很多）1.首先下载安装包，进行解压。路径：迅雷云盘2.然后进入目录中
  • Linux中es启动成功，windows服务器访问不了的解决方案 码代码的小仙女 笔记linuxwindowselasticsearch
    1.在Linux服务器中安装elasticsearch。在bin目录下执行./elasticsearch报错信息：org.elasticsearch.bootstrap.StartupException:java.lang.RuntimeException:cannotrunelasticsearchasrootatorg.elasticsearch.bootstrap.Elasticsearch
  • 基于springboot的鲜花销售商城网站 程序猿麦小七 毕业设计Java后台JavaWebspringbootjava后端
    项目描述临近学期结束，还是毕业设计，你还在做java程序网络编程，期末作业，老师的作业要求觉得大了吗?不知道毕业设计该怎么办?网页功能的数量是否太多?没有合适的类型或系统?等等。这里根据疫情当下，你想解决的问题，今天给大家介绍一篇基于springboot的鲜花销售商城网站。功能需求本文设计并实现的商城系统，通过互联网来实现电子商城这一新兴产业，电子商城主要依靠于计算机互联网技术。如果缺少了这个技术
  • Netty长连接 JIU_WW nettywebsocketjavatcp
    1.长连接的概念目录1.长连接的概念2.Netty对长连接的支持2.1内置协议支持2.2连接状态管理2.3资源优化3.Netty长连接与WebSocket的关系4.实现长连接的两种典型方式4.1基于TCP自定义协议4.2基于WebSocket5.长连接的关键优化策略6.性能对比：Nettyvs传统实现总结长连接指客户端与服务器建立一次连接后，保持该连接持续打开，供多次数据传输使用。与短连接（每次请
  • ssm002学院党员管理系统(文档+源码)_kaic 开心毕设 开发语言vue.js前端javascriptjava
    摘要互联网发展至今，无论是其理论还是技术都已经成熟，而且它广泛参与在社会中的方方面面。它让信息都可以通过网络传播，搭配信息管理工具可以很好地为人们提供服务。针对鄂尔多斯应用技术学院党员信息管理混乱，出错率高，信息安全性差，劳动强度大，费时费力等问题，采用鄂尔多斯应用技术学院党员管理系统可以有效管理，使信息管理能够更加科学和规范。鄂尔多斯应用技术学院党员管理系统在Eclipse环境中，使用Java语
  • springboot527基于Java企业项目管理系统(论文+源码)_kaic 开心毕设 数据库rabbitmqkafka
    摘要如今社会上各行各业，都喜欢用自己行业的专属软件工作，互联网发展到这个时候，人们已经发现离不开了互联网。新技术的产生，往往能解决一些老技术的弊端问题。因为传统企业项目管理系统信息管理难度大，容错率低，管理人员处理数据费工费时，所以专门为解决这个难题开发了一个企业项目管理系统，可以解决许多问题。企业项目管理系统按照操作主体分为管理员和用户。管理员的功能包括操作日志管理、字典管理、论坛管理、公告管理
  • 解决IDEA创建SpringBoot项目时不能选择java8的问题 奔跑吧小吕 intellij-ideajavaide
    问题原因：当我创建一个springboot项目时，发现选不了java8了，查看官方文档之后，springboot不在支持java8了。解决方式：改成阿里云的服务
  • java.lang.NoSuchMethodError: org.elasticsearch.client.RestClient.performRequest(Ljava/lang/String；Lj 频繁输入，积极输出 eses
    es创建索引时，报：java.lang.NoSuchMethodError:org.elasticsearch.client.RestClient.performRequest(Ljava/lang/String;Ljava/lang/String;Ljava/util/Map;Lorg/apache/http/HttpEntity;[Lorg/apache/http/Header;)Lorg/e
  • linux常用基础命令_最新版 脚大江山稳 linux
    常用命令查看当前目录下个各个文件大小查看当前系统储存使用情况查看当前路径删除当前目录下所有包含".log"的文件linux开机启动jar更改自动配置文件后操作关闭自启动linux静默启动java服务查询端口被占用查看软件版本重启关机开机启动取别名清空当前行创建文件touch创建文件夹查找文件/文件名/大小查找查看文件内容cat/more删除文件或文件夹管道符|过滤grep命令echo命令输出内容重
  • Hutool - Setting：功能更强大的 Setting 配置文件和 Properties 封装 五行星辰 业务系统应用技术开发语言java后端
    一、简介在Java开发中，配置文件是管理项目配置信息的重要手段，常见的配置文件格式有.properties文件。然而，传统的Properties类在处理配置信息时功能相对有限，例如不支持分组、注释等。Hutool-Setting模块对配置文件进行了更强大的封装，提供了比Properties更丰富的功能，支持分组配置、自动加载、变量引用等，让配置文件的管理和使用更加便捷。二、引入依赖如果你使用Mav
  • 探寻 Hutool - System：开启系统信息便捷获取之旅 五行星辰 业务系统应用技术java后端
    Hutool-System：系统参数调用封装（JVM信息等）一、简介在Java开发中，有时需要获取系统的相关信息，例如JVM的配置信息、操作系统信息、用户信息等。Java本身提供了一些API来获取这些信息，但使用起来较为分散和复杂。Hutool-System模块对这些系统参数的调用进行了封装，提供了统一、便捷的接口，让开发者可以更轻松地获取各种系统信息。二、引入依赖如果你使用Maven项目，在po
  • JAVA版本GDAL安装使用教程(详细步骤） Roc-xb javaGDAL
    GDAL由加拿大航天代理局开发，采用MIT/X开源协议，由OpenSourceGeospatialFoundation维护。它通过抽象数据模型统一支持多种地理数据格式，包括栅格数据（如GeoTIFF、JPEG2000、HDF）和矢量数据（如Shapefile、GeoJSON）。其跨平台性支持Windows、Linux、macOS等操作系统，并提供了Python、C/C++、Java等多种语言接口一
  • 【Spring】配置文件的使用 m0_74823507 面试学习路线阿里巴巴springjava后端
    在Spring框架中，application.properties（或application.yml）文件用于配置Spring应用程序的各种属性。我们可以通过多种方式来使用这些配置，包括使用@Value和@ConfigurationProperties注解来绑定配置到Java对象。下面是对不同配置类型的说明，以及如何在代码中使用它们的示例。1.配置变量（单个属性）可以在application.pr
  • J-LangChain，用Java实现LangChain编排！轻松加载PDF、切分文档、向量化存储，再到智能问答 花千树-010 JLangChain-TGlangchainjavapdfAIGCnlpAI编程
    Java如何玩转大模型编排、RAG、Agent？？？在自然语言处理（NLP）的浪潮中，LangChain作为一种强大的模型编排框架，已经在Python社区中广受欢迎。然而，对于Java开发者来说，能否有一个同样高效、灵活的工具来实现类似功能？答案是肯定的！今天，我们将聚焦J-LangChain——一个专为Java打造的LangChain实现，带你探索如何用Java语言轻松构建从PDF处理到智能问答
  • 【Java】如何高效计算斐波那契数列：递归与循环的比较与优化 小ᶻ☡꙳ᵃⁱᵍᶜ꙳ Javajava开发语言
    博客主页：[小ᶻ☡꙳ᵃⁱᵍᶜ꙳]本文专栏:Java文章目录前言斐波那契数列的递归实现1.递归的基本思路2.递归实现的细节解析3.递归效率分析斐波那契数列的循环实现1.循环实现的代码2.循环实现的细节解析3.循环实现的优缺点4.举例说明优化：递归与循环的改进1.记忆化递归（Memoization）2.优化效果总结前言斐波那契数列是计算机科学和数学中经典的数列之一，它不仅在理论上具有重要意义，在实际编
  • MySQL的日期时间类型 大地爱 面试学习路线阿里巴巴mysql数据库
    一MySQL的日期时间类型MySQL数据库的日期时间类型有date、time和datetime类型，还有timestamp类型，在Java代码中无论日期时间是什么样的格式，转换sql语句时统一为yyyy-MM-ddHH:mm:ss.S(Timestamp)的格式，创建案例简单演示。1.1创建数据库表CREATETABLE`apple`(`id`varchar(255)DEFAULTNULL,`da
  • 统一思想认识 永夜-极光 思想
    1.统一思想认识的基础,才能有的放矢  原因:    总有一种描述事物的方式最贴近本质,最容易让人理解.    如何让教育更轻松,在于找到最适合学生的方式.          难点在于,如何模拟对方的思维基础选择合适的方式.   &
  • Joda Time使用笔记 bylijinnan javajoda time
    Joda Time的介绍可以参考这篇文章： http://www.ibm.com/developerworks/cn/java/j-jodatime.html 工作中也常常用到Joda Time，为了避免每次使用都查API，记录一下常用的用法：     /** * DateTime变化（增减） */ @Tes
  • FileUtils API eksliang FileUtilsFileUtils API
    转载请出自出处：http://eksliang.iteye.com/blog/2217374 一、概述 这是一个Java操作文件的常用库，是Apache对java的IO包的封装，这里面有两个非常核心的类FilenameUtils跟FileUtils，其中FilenameUtils是对文件名操作的封装;FileUtils是文件封装，开发中对文件的操作，几乎都可以在这个框架里面找到。 非常的好用。
  • 各种新兴技术 不懂事的小屁孩 技术
    1:gradle Gradle 是以 Groovy 语言为基础，面向Java应用为主。基于DSL（领域特定语言）语法的自动化构建工具。 现在构建系统常用到maven工具，现在有更容易上手的gradle， 搭建java环境: http://www.ibm.com/developerworks/cn/opensource/os-cn-gradle/ 搭建android环境： http://m
  • tomcat6的https双向认证 酷的飞上天空 tomcat6
    1.生成服务器端证书 keytool -genkey -keyalg RSA -dname "cn=localhost,ou=sango,o=none,l=china,st=beijing,c=cn" -alias server -keypass password -keystore server.jks -storepass password -validity 36
  • 托管虚拟桌面市场势不可挡 蓝儿唯美
    用户还需要冗余的数据中心，dinCloud的高级副总裁兼首席营销官Ali Din指出。该公司转售一个MSP可以让用户登录并管理和提供服务的用于DaaS的云自动化控制台，提供服务或者MSP也可以自己来控制。 在某些情况下，MSP会在dinCloud的云服务上进行服务分层，如监控和补丁管理。 MSP的利润空间将根据其参与的程度而有所不同，Din说。 “我们有一些合作伙伴负责将我们推荐给客户作为个
  • spring学习——xml文件的配置 a-john spring
    在Spring的学习中，对于其xml文件的配置是必不可少的。在Spring的多种装配Bean的方式中，采用XML配置也是最常见的。以下是一个简单的XML配置文件： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.or
  • HDU 4342 History repeat itself 模拟 aijuans 模拟
    来源：http://acm.hdu.edu.cn/showproblem.php?pid=4342 题意：首先让求第几个非平方数，然后求从1到该数之间的每个sqrt(i)的下取整的和。 思路：一个简单的模拟题目，但是由于数据范围大，需要用__int64。我们可以首先把平方数筛选出来，假如让求第n个非平方数的话，看n前面有多少个平方数，假设有x个，则第n个非平方数就是n+x。注意两种特殊情况，即
  • java中最常用jar包的用途 asia007 java
    java中最常用jar包的用途 jar包用途axis.jarSOAP引擎包commons-discovery-0.2.jar用来发现、查找和实现可插入式接口，提供一些一般类实例化、单件的生命周期管理的常用方法.jaxrpc.jarAxis运行所需要的组件包saaj.jar创建到端点的点到点连接的方法、创建并处理SOAP消息和附件的方法，以及接收和处理SOAP错误的方法.  w
  • ajax获取Struts框架中的json编码异常和Struts中的主控制器异常的解决办法 百合不是茶 jsjson编码返回异常
    一:ajax获取自定义Struts框架中的json编码  出现以下 问题:       1,强制flush输出  json编码打印在首页 2, 不强制flush js会解析json 打印出来的是错误的jsp页面   却没有跳转到错误页面 3,  ajax中的dataType的json 改为text 会
  • JUnit使用的设计模式 bijian1013 java设计模式JUnit
    JUnit源代码涉及使用了大量设计模式 1、模板方法模式（Template Method）         定义一个操作中的算法骨架，而将一些步骤延伸到子类中去，使得子类可以不改变一个算法的结构，即可重新定义该算法的某些特定步骤。这里需要复用的是算法的结构，也就是步骤，而步骤的实现可以在子类中完成。   
  • Linux常用命令（摘录） sunjing crondchkconfig
    chkconfig --list   查看linux所有服务 chkconfig --add servicename 添加linux服务 netstat -apn | grep 8080  查看端口占用 env 查看所有环境变量 echo $JAVA_HOME 查看JAVA_HOME环境变量   安装编译器 yum install -y gcc
  • 【Hadoop一】Hadoop伪集群环境搭建 bit1129 hadoop
     结合网上多份文档，不断反复的修正hadoop启动和运行过程中出现的问题，终于把Hadoop2.5.2伪分布式安装起来，跑通了wordcount例子。Hadoop的安装复杂性的体现之一是，Hadoop的安装文档非常多，但是能一个文档走下来的少之又少，尤其是Hadoop不同版本的配置差异非常的大。Hadoop2.5.2于前两天发布，但是它的配置跟2.5.0，2.5.1没有分别。 &nb
  • Anychart图表系列五之事件监听 白糖_ chart
    创建图表事件监听非常简单：首先是通过addEventListener('监听类型',js监听方法)添加事件监听，然后在js监听方法中定义具体监听逻辑。 以钻取操作为例，当用户点击图表某一个point的时候弹出point的name和value，代码如下： <script> //创建AnyChart var chart = new AnyChart(); //添加钻取操作&quo
  • Web前端相关段子 braveCS web前端
    Web标准：结构、样式和行为分离   使用语义化标签 0）标签的语义：使用有良好语义的标签，能够很好地实现自我解释，方便搜索引擎理解网页结构，抓取重要内容。去样式后也会根据浏览器的默认样式很好的组织网页内容，具有很好的可读性，从而实现对特殊终端的兼容。 1）div和span是没有语义的：只是分别用作块级元素和行内元素的区域分隔符。当页面内标签无法满足设计需求时，才会适当添加div
  • 编程之美-24点游戏 bylijinnan 编程之美
    import java.util.ArrayList; import java.util.Arrays; import java.util.HashSet; import java.util.List; import java.util.Random; import java.util.Set; public class PointGame { /**编程之美
  • 主页面子页面传值总结 chengxuyuancsdn 总结
    1、showModalDialog returnValue是javascript中html的window对象的属性,目的是返回窗口值,当用window.showModalDialog函数打开一个IE的模式窗口时,用于返回窗口的值 主界面 var sonValue=window.showModalDialog("son.jsp"); 子界面 window.retu
  • [网络与经济]互联网+的含义 comsci 互联网+
          互联网+后面是一个人的名字 = 网络控制系统       互联网+你的名字 =  网络个人数据库       每日提示:如果人觉得不舒服,千万不要外出到处走动,就呆在床上,玩玩手游,更不能够去开车,现在交通状况不
  • oracle 创建视图 with check option daizj 视图vieworalce
    我们来看下面的例子： create or replace view testview as select empno,ename from emp where ename like ‘M%’ with check option; 这里我们创建了一个视图，并使用了with check option来限制了视图。 然后我们来看一下视图包含的结果： select * from testv
  • ToastPlugin插件在cordova3.3下使用 dibov Cordova
        自己开发的Todos应用，想实现“ 再按一次返回键退出程序 ”的功能，采用网上的ToastPlugins插件，发现代码或文章基本都是老版本，运行问题比较多。折腾了好久才弄好。下面吧基于cordova3.3下的ToastPlugins相关代码共享。       ToastPlugin.java package&nbs
  • C语言22个系统函数 dcj3sjt126com cfunction
    C语言系统函数一、数学函数下列函数存放在math.h头文件中Double floor(double num) 求出不大于num的最大数。Double fmod(x, y) 求整数x/y的余数。Double frexp(num, exp); double num; int *exp; 将num分为数字部分（尾数）x和 以2位的指数部分n，即num=x*2n，指数n存放在exp指向的变量中，返回x。D
  • 开发一个类的流程 dcj3sjt126com 开发
    本人近日根据自己的开发经验总结了一个类的开发流程。这个流程适用于单独开发的构件，并不适用于对一个项目中的系统对象开发。开发出的类可以存入私人类库，供以后复用。   以下是开发流程： 1. 明确类的功能，抽象出类的大概结构 2. 初步设想类的接口 3. 类名设计（驼峰式命名） 4. 属性设置(权限设置) 判断某些变量是否有必要作为成员属
  • java 并发 shuizhaosi888 java 并发
    能够写出高伸缩性的并发是一门艺术   在JAVA SE5中新增了3个包 java.util.concurrent java.util.concurrent.atomic java.util.concurrent.locks 在java的内存模型中，类的实例字段、静态字段和构成数组的对象元素都会被多个线程所共享，局部变量与方法参数都是线程私有的，不会被共享。
  • Spring Security（11）——匿名认证 234390216 Spring SecurityROLE_ANNOYMOUS匿名
    匿名认证 目录 1.1     配置 1.2     AuthenticationTrustResolver          对于匿名访问的用户，Spring Security支持为其建立一个匿名的AnonymousAuthenticat
  • NODEJS项目实践0.2[ express,ajax通信...] 逐行分析JS源代码 Ajaxnodejsexpress
      一、前言         通过上节学习，我们已经        ubuntu系统搭建了一个可以访问的nodejs系统，并做了nginx转发。本节原要做web端服务 及 mongodb的存取，但写着写着，web端就
  • 在Struts2 的Action中怎样获取表单提交上来的多个checkbox的值 lhbthanks javahtmlstrutscheckbox
    第一种方法：获取结果String类型 在 Action 中获得的是一个 String 型数据，每一个被选中的 checkbox 的 value 被拼接在一起，每个值之间以逗号隔开(,)。 所以在 Action 中定义一个跟 checkbox 的 name 同名的属性来接收这些被选中的 checkbox 的 value 即可。 以下是实现的代码： 前台 HTML 代码：
  • 003.Kafka基本概念 nweiren hadoopkafka
    Kafka基本概念：Topic、Partition、Message、Producer、Broker、Consumer。 Topic：             消息源（Message）的分类。 Partition：             Topic物理上的分组，一
  • Linux环境下安装JDK roadrunners jdklinux
    1、准备工作 创建JDK的安装目录： mkdir -p /usr/java/   下载JDK，找到适合自己系统的JDK版本进行下载： http://www.oracle.com/technetwork/java/javase/downloads/index.html   把JDK安装包下载到/usr/java/目录，然后进行解压： tar -zxvf jre-7
  • Linux忘记root密码的解决思路 tomcat_oracle linux
    1：使用同版本的linux启动系统，chroot到忘记密码的根分区passwd改密码 　　2：grub启动菜单中加入init=/bin/bash进入系统，不过这时挂载的是只读分区。根据系统的分区情况进一步判断. 　　3: grub启动菜单中加入 single以单用户进入系统. 　　4:用以上方法mount到根分区把/etc/passwd中的root密码去除 　　例如: 　　ro
  • 跨浏览器 HTML5 postMessage 方法以及 message 事件模拟实现 xueyou jsonpjquery框架UIhtml5
    postMessage 是 HTML5 新方法，它可以实现跨域窗口之间通讯。到目前为止，只有 IE8+, Firefox 3, Opera 9, Chrome 3和 Safari 4 支持，而本篇文章主要讲述 postMessage 方法与 message 事件跨浏览器实现。postMessage 方法 JSONP 技术不一样，前者是前端擅长跨域文档数据即时通讯，后者擅长针对跨域服务端数据通讯，p
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他