Java得到请求客户端的真人真事IP地址多中方法结合,Java得到客户端真实IP地址的三种艺术

在JSP里,获取客户端的IP地址的法子是:request.getRemoteAddr(),这种方法在大多动静下都以一蹴而就的。可是在通过了Apache,Squid等反向代理软件就无法获取到客户端的真实性IP地址了。

在JSP里,获取客户端的IP地址的不2诀如若:request.getRemoteAddr(),这种艺术在多数场馆下都是卓有成效的。不过在经过了Apache,Squid等反向代理软件就不能够获取到客户端的真人真事IP地址了。

在JSP里,获取客户端的IP地址的章程是:request.getRemoteAddr(),这种办法在大多情景下都以立见功效的。可是在经过了Apache,Squid等反向代理软件就不能获取到客户端的诚惶诚恐IP地址了。

 

万1采取了反向代理软件,将 的U猎豹CS陆L反向代理为
/
的U奥迪Q5L时,用request.getRemoteAddr()方法赢得的IP地址是:1二7.0.0.一 或
1九二.16八.一.1十,而并不是客 户端的真人真事IP。

如果利用了反向代理软件,将 的URubiconL反向代理为
/
的U纳瓦拉L时,用request.getRemoteAddr()方法得到的IP地址是:12七.0.0.一 或 192.16八.一.110,而并不是客
户端的实在IP。

假诺使用了反向代理软件,将 的U本田UR-VL反向代理为
/
的U昂CoraL时,用request.getRemoteAddr()方法获得的IP地址是:1二七.0.0.一 或 1九2.16八.一.1拾,而并不是客户端的忠实IP。

转:

由此代理以往,由于在客户端和劳务时期扩充了中间层,因而服务器不能直接得到客户端的IP,服务器端应用也无能为力直接通过转载呼吁的地点重返给客户端。然而在中间转播呼吁的HTTP头音信中,扩大了X-FOEnclaveWAMuranoDED-FO奥迪Q五音讯。用以追踪原有的客户端IP地址和原先客户端请求的服务器地址。当大家访问
/index.jsp/
时,其实并不是大家浏览器真正访问到了服务器上的index.jsp文件,而是先由代理服务器去做客
/index.jsp
,代理服务器再将造访到的结果回到给大家的浏览器,因为是代理服务器去访问index.jsp的,所以index.jsp中通过
request.getRemoteAddr()的点子获得的IP实际上是代理服务器的地点,并不是客户端的IP地址。

由此代理将来,由于在客户端和劳动时期增添了中间层,因而服务器不能直接拿到客户端的IP,服务器端应用也无从直接通过转载呼吁的地点重返给客户端。但是在转化呼吁的HTTP头音信中,扩张了X-FOENVISIONWA奥迪Q5DED-FOLacrosse音信。用以追踪原有的客户端IP地址和原先客户端请求的服务器地址。当大家访问
/index.jsp/
时,其实并不是大家浏览器真正访问到了服务器上的index.jsp文件,而是先由代理服务器去做客Java得到请求客户端的真人真事IP地址多中方法结合,Java得到客户端真实IP地址的三种艺术。
/index.jsp
,代理服务器再将做客到的结果回到给我们的浏览器,因为是代理服务器去访问index.jsp的,所以index.jsp中经过
request.getRemoteAddr()的秘籍获得的IP实际上是代理服务器的地点,并不是客户端的IP地址。

因而代理今后,由于在客户端和劳动时期扩展了中间层,因此服务器不可能直接获得客户端的IP,服务器端应用也无从直接通过转载呼吁的地方再次来到给客户端。然则在转化呼吁的HTTP头音信中,扩大了X-FORAV四WAENVISIONDED-FOLX570音讯。用以跟踪原有的客户端IP地址和原先客户端请求的服务器地址。当我们访问
/index.jsp/
时,其实并不是大家浏览器真正访问到了服务器上的index.jsp文件,而是先由代理服务器去访问
,代理服务器再将做客到的结果再次回到给大家的浏览器,因为是代理服务器去拜访index.jsp的,所以index.jsp中经过request.getRemoteAddr()的艺术得到的IP实际上是代理服务器的地方,并不是客户端的IP地址。

 

于是可得出得到客户端真实IP地址的办法一:

于是乎可得出获得客户端真实IP地址的诀要1:

于是可得出得到客户端真实IP地址的艺术一:

在JSP里,获取客户端的IP地址的办法是:request.getRemoteAddr(),这种方法在大部景色下都以行得通的。可是在经过了Apache,Squid等反向代理软件就不可能取获得客户端的诚实IP地址了。

    public String getRemortIP(HttpServletRequest request) { 
      if (request.getHeader("x-forwarded-for") == null) { 
       return request.getRemoteAddr(); 
      } 
      return request.getHeader("x-forwarded-for"); 
     } 

 

  1. public String getRemortIP(HttpServletRequest request) { 
  2.   if (request.getHeader(“x-forwarded-for”) == null) { 
  3.    return request.getRemoteAddr(); 
  4.   } 
  5.   return request.getHeader(“x-forwarded-for”); 
  6.  } 

  若是运用了反向代理软件,将 :2046/
的UGL450L反向代理为 /
的UHummerH二L时,用request.getRemoteAddr()方法获得的IP地址是:1二7.0.0.一 或 1玖贰.16八.1.110,而并不是客
户端的忠实IP。

然则当本身访问 /index.jsp/
时,重回的IP地址始终是unknown,也并不是如上所示的1二7.0.0.壹 或
1九2.16八.1.1十了,而自己访问
时,则能回去客户端的实在IP地址,写了个章程去印证。原因出在了Squid上。squid.conf
的配制文件 forwarded_for 项私下认可是为on,假若 forwarded_for 设成了 off
则:X-Forwarded-For: unknown

    public String getRemortIP(HttpServletRequest request) { 
      if (request.getHeader("x-forwarded-for") == null) { 
       return request.getRemoteAddr(); 
      } 
      return request.getHeader("x-forwarded-for"); 
     } 

可是当本身访问 /index.jsp/
时,再次回到的IP地址始终是unknown,也并不是如上所示的1贰七.0.0.一 或 1九二.16八.一.1拾了,而自个儿访问
时,则能再次回到客户端的诚实IP地址,写了个法子去验证。原因出在了Squid上。squid.conf
的配制文件 forwarded_for 项暗许是为on,假如 forwarded_for 设成了 off
 则:X-Forwarded-For: unknown

  经过代理以往,由于在客户端和服务时期扩张了中间层,因而服务器无法直接获得客户端的IP,服务器端应用也不知所可直接通过转发呼吁的地点再次来到给
客户端。可是在转化呼吁的HTTP头新闻中,扩展了X-FOWranglerWA大切诺基DED-FOLAND音信。用以追踪原有的客户端IP地址和原本客户端请求的服务器地址。当
大家访问 /index.jsp/
时,其实并不是我们浏览器真正访问到了服务器上的index.jsp文件,而是先由代理服务器去做客
:2046/index.jsp
,代理服务器再将做客到的结果重返给大家的浏览器,因为是代理服务器去拜访index.jsp的,所以index.jsp中经过
request.getRemoteAddr()的艺术得到的IP实际上是代理服务器的地址,并不是客户端的IP地址。

于是可得出获得客户端真实IP地址的办法二:

 

于是乎可得出得到客户端真实IP地址的秘诀2:

  于是可得出得到客户端真实IP地址的艺术一:
Java得到请求客户端的真人真事IP地址多中方法结合,Java得到客户端真实IP地址的三种艺术。public String getRemortIP(HttpServletRequest request) {
  if (request.getHeader(“x-forwarded-for”) == null) {
  return request.getRemoteAddr();
  }
  return request.getHeader(“x-forwarded-for”);
  }
只是当作者访问 /index.jsp/
时,再次回到的IP地址始终是unknown,也并不是如上所示的1二七.0.0.一 或 1玖二.16八.1.1十了,而自己访问
:2046/index.jsp
时,则能重临客户端的忠实IP地址,写了个点子去申明。原因出在了Squid上。squid.conf
的配制文件 forwarded_for 项默许是为on,假若 forwarded_for 设成了 off
 则:X-Forwarded-For: unknown

    public String getIpAddr(HttpServletRequest request) { 
           String ip = request.getHeader("x-forwarded-for"); 
           if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
               ip = request.getHeader("Proxy-Client-IP"); 
           } 
           if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
               ip = request.getHeader("WL-Proxy-Client-IP"); 
           } 
           if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
               ip = request.getRemoteAddr(); 
           } 
           return ip; 
       } 

可是当自个儿访问 /index.jsp/
时,重回的IP地址始终是unknown,也并不是如上所示的1二7.0.0.一 或 19二.16捌.1.110了,而自身访问

时,则能回去客户端的真人真事IP地址,写了个格局去印证。原因出在了Squid上。squid.conf
的配制文件 forwarded_for 项暗中认可是为on,倘若 forwarded_for 设成了 off
 则:X-Forwarded-For: unknown

  1. public String getIpAddr(HttpServletRequest request) { 
  2.        String ip = request.getHeader(“x-forwarded-for”); 
  3.        if(ip == null || ip.length() == 0 || “unknown”.equalsIgnoreCase(ip)) { 
  4.            ip = request.getHeader(“Proxy-Client-IP”); 
  5.        } 
  6.        if(ip == null || ip.length() == 0 || “unknown”.equalsIgnoreCase(ip)) { 
  7.            ip = request.getHeader(“WL-Proxy-Client-IP”); 
  8.        } 
  9.        if(ip == null || ip.length() == 0 || “unknown”.equalsIgnoreCase(ip)) { 
  10.            ip = request.getRemoteAddr(); 
  11.        } 
  12.        return ip; 
  13.    } 

  于是可得出得到客户端真实IP地址的措施贰:
public String getIpAddr(HttpServletRequest request) {
  String ip = request.getHeader(“x-forwarded-for”);
www.5929.com,  if(ip == null || ip.length() == 0 || “unknown”.equalsIgnoreCase(ip))
{
  ip = request.getHeader(“Proxy-Client-IP”);
  }
  if(ip == null || ip.length() == 0 || “unknown”.equalsIgnoreCase(ip))
{
  ip = request.getHeader(“WL-Proxy-Client-IP”);
  }
  if(ip == null || ip.length() == 0 || “unknown”.equalsIgnoreCase(ip))
{
  ip = request.getRemoteAddr();
  }
  return ip;
  }
 但是,假如通过了所有人家反向代理的话,X-Forwarded-For的值并不仅多个,而是一串Ip值,究竟哪位才是真的的用户端的忠实IP呢?

而是,借使通过了一而再串反向代理的话,X-Forwarded-For的值并不仅八个,而是1串Ip值,终究哪位才是真的的用户端的真实性IP呢?

于是可得出获得客户端真实IP地址的法子贰:

只是,假诺通过了层层反向代理的话,X-Forwarded-For的值并不仅仅四个,而是一串Ip值,毕竟哪个才是的确的用户端的真实IP呢?

  答案是取X-Forwarded-For中首先个非unknown的有效IP字符串。

答案是取X-Forwarded-For中首先个非unknown的可行IP字符串。

 

答案是取X-Forwarded-For中首先个非unknown的有用IP字符串。

  如:X-Forwarded-For:192.16八.一.1十, 1九二.168.一.120, 192.16八.一.130,
1玖二.168.一.100用户实际IP为: 192.168.壹.1十

如:X-Forwarded-For:1玖2.16八.1.110, 1玖二.168.一.120, 1玖二.16捌.壹.130,
1玖二.16八.1.十0用户实际IP为: 1玖贰.16八.一.110

    public String getIpAddr(HttpServletRequest request) { 
           String ip = request.getHeader("x-forwarded-for"); 
           if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
               ip = request.getHeader("Proxy-Client-IP"); 
           } 
           if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
               ip = request.getHeader("WL-Proxy-Client-IP"); 
           } 
           if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
               ip = request.getRemoteAddr(); 
           } 
           return ip; 
       } 

如:X-Forwarded-For:1九贰.16八.一.110, 1玖二.16捌.一.120, 1玖二.16八.1.130,
1九二.16捌.一.拾0用户实际IP为: 1玖二.168.一.1十

二零一零-0肆-0二 1陆:5九近年来做1个有惊无险体系,需求对用户的 ip 和 mac
地址举办求证,这里用到收获客户端ip和mac地址的两个办法,留存。

 

如上措施还特别的话就选用如下方法:

壹.得到客户端ip地址( 这一个必须从客户端传到后台):
jsp页面下,很简单,request.getRemoteAddr() ;
因为系统的VIew层是用JSF来兑现的,因而页面上无奈直接拿走临近request,在bean里做了个强制转变
   public String getMyIP() {
try {
FacesContext fc = FacesContext.getCurrentInstance();
HttpServletRequest request =
(HttpServletRequest)fc.getExternalContext().getRequest();
return request.getRemoteAddr();
}
catch (Exception e) {
e.printStackTrace();
}
return “”;
}

而是,如果由此了数以万计反向代理的话,X-Forwarded-For的值并不仅仅贰个,而是壹串Ip值,毕竟哪位才是确实的用户端的忠实IP呢?

 

二.获得客户端mac地址
调用window的下令,在后台Bean里金镶玉裹福禄双全 通过ip来获得mac地址。方法如下:

答案是取X-Forwarded-For中第四个非unknown的有效性IP字符串。

[java] view
plain copy
 www.5929.com 1

public String getMACAddress(String ip){
String str = “”;
String macAddress = “”;
try {
Process p = Runtime.getRuntime().exec(“nbtstat -A ” + ip);
InputStreamReader ir = new InputStreamReader(p.getInputStream());
LineNumberReader input = new LineNumberReader(ir);
for (int i = 1; i < 100; i++) {
str = input.readLine();
if (str != null) {
if (str.indexOf(“MAC Address”) > 1) {
macAddress = str.substring(str.indexOf(“MAC Address”) + 14,
str.length());
break;
}
}
}
} catch (IOException e) {
e.printStackTrace(System.out);
}
return macAddress;
}

如:X-Forwarded-For:1玖二.168.一.1十, 19二.168.1.120, 1九二.16捌.1.130,
19二.168.壹.十0用户真正IP为: 1九二.168.壹.1十

  1. /** 
  2.      * 获取当前网络ip 
  3.      * @param request 
  4.      * @return 
  5.      */  
  6.     public String getIpAddr(HttpServletRequest request){  
  7.         String ipAddress = request.getHeader(“x-forwarded-for”);  
  8.             if(ipAddress == null || ipAddress.length() == 0 || “unknown”.equalsIgnoreCase(ipAddress)) {  
  9.                 ipAddress = request.getHeader(“Proxy-Client-IP”);  
  10.             }  
  11.             if(ipAddress == null || ipAddress.length() == 0 || “unknown”.equalsIgnoreCase(ipAddress)) {  
  12.                 ipAddress = request.getHeader(“WL-Proxy-Client-IP”);  
  13.             }  
  14.             if(ipAddress == null || ipAddress.length() == 0 || “unknown”.equalsIgnoreCase(ipAddress)) {  
  15.                 ipAddress = request.getRemoteAddr();  
  16.                 if(ipAddress.equals(“127.0.0.1”) || ipAddress.equals(“0:0:0:0:0:0:0:1”)){  
  17.                     //依照网卡取本机配置的IP  
  18.                     InetAddress inet=null;  
  19.                     try {  
  20.                         inet = InetAddress.getLocalHost();  
  21.                     } catch (UnknownHostException e) {  
  22.                         e.printStackTrace();  
  23.                     }  
  24.                     ipAddress= inet.getHostAddress();  
  25.                 }  
  26.             }  
  27.             //对于通过多个代理的动静,第一个IP为客户端真实IP,多少个IP依照’,’分割  
  28.             if(ipAddress!=null && ipAddress.length()>15){ //”***.***.***.***”.length() = 15  
  29.                 if(ipAddress.indexOf(“,”)>0){  
  30.                     ipAddress = ipAddress.substring(0,ipAddress.indexOf(“,”));  
  31.                 }  
  32.             }  
  33.             return ipAddress;   
  34.     }  

补充:
有关获取IP地址的主意,方今在linux下有三个教训,假若单独通过InetAddress来获得IP地址,就能够并发在区别的机械上IP地址区别的难点。
InetAddress.getLocalHost().getAddress()
实际上是依靠hostname来赢得IP地址的。linux系统在刚刚装完私下认可的hostname是localhost,所以经过地点代码获取到的本机
ip正是1二七.0.0.壹, 相对应,举个例子小编的hostname就是rjlin.atsig.com
重返的ip地址确是atsig.com的位置。临时使用下边代码来拍卖,当然还相当不足利索:
public static byte[] getIp() throws UnknownHostException {
byte[] b = InetAddress.getLocalHost().getAddress();
Enumeration allNetInterfaces = null;
try {
allNetInterfaces = NetworkInterface.getNetworkInterfaces();
} catch (SocketException e) {
e.printStackTrace();
}
InetAddress ip = null;
NetworkInterface netInterface = null;
while (allNetInterfaces.hasMoreElements()) {
netInterface = (NetworkInterface) allNetInterfaces.nextElement();
if (netInterface.getName().trim().equals(“eth0”)){
Enumeration addresses = netInterface.getInetAddresses();
while (addresses.hasMoreElements()) {
ip = (InetAddress) addresses.nextElement();
}
break;
}
}
if (ip != null && ip instanceof Inet4Address) {
return b = ip.getAddress();
}
return b;
}

如上办法还百般的话就采纳如下方法:

 

/**
     * 获取当前网络ip
     * @param request
     * @return
     */
    public String getIpAddr(HttpServletRequest request){
        String ipAddress = request.getHeader("x-forwarded-for");
            if(ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getHeader("Proxy-Client-IP");
            }
            if(ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getHeader("WL-Proxy-Client-IP");
            }
            if(ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getRemoteAddr();
                if(ipAddress.equals("127.0.0.1") || ipAddress.equals("0:0:0:0:0:0:0:1")){
                    //根据网卡取本机配置的IP
                    InetAddress inet=null;
                    try {
                        inet = InetAddress.getLocalHost();
                    } catch (UnknownHostException e) {
                        e.printStackTrace();
                    }
                    ipAddress= inet.getHostAddress();
                }
            }
            //对于通过多个代理的情况,第一个IP为客户端真实IP,多个IP按照','分割
            if(ipAddress!=null && ipAddress.length()>15){ //"***.***.***.***".length() = 15
                if(ipAddress.indexOf(",")>0){
                    ipAddress = ipAddress.substring(0,ipAddress.indexOf(","));
                }
            }
            return ipAddress; 
    }

 

注:转载

 

 

 

 

Leave a Comment.