Optimizando el código Java
-
06-07-2019 - |
Pregunta
¿Cómo puedo optimizar este código? Hice IPFilter y necesito optimizarlo.
package com.ipfilter;
import java.util.HashMap;
import java.util.Map;
/**
* IPFilter
*
* Loads given IP addresses to memory, so you can easily check if ip addres has been blocked
*/
public class IPFilter {
private Map<Integer, IPFilter> filter = new HashMap<Integer, IPFilter>();
/**
* Convert String ip address to Integer array and then calls add ip method
* @param ip
* @return
*/
public void addIP(String ip)
{
int[] numbers = convert(ip);
addIP(numbers, 0);
}
/**
* Convert String ip address to Integer array
* @param ip
* @return
*/
private int[] convert(String ip) {
String[] strings = ip.split("\\.");
int[] numbers = new int[strings.length];
for(int i = 0; i < strings.length; i++)
{
numbers[i] = Integer.parseInt(strings[i]);
}
return numbers;
}
/**
* Add ip address to memory
* @param ip
* @param level
*/
private void addIP(int[] ip, int level) {
if(level < ip.length)
{
if (filter.containsKey(ip[level])) {
filter.get(ip[level]).addIP(ip, level + 1);
} else {
filter.put(ip[level], new IPFilter());
filter.get(ip[level]).addIP(ip, level + 1);
}
}
}
/**
* Checks if ip address is in filter
* @param ip
* @return
*/
public boolean isBlocked(String ip)
{
return isBlocked(filter, convert(ip), 0);
}
/**
* Check if ip address is blocked
* @param list
* @param ip
* @param level
* @return
*/
private boolean isBlocked(Map<Integer, IPFilter> list, int[] ip, int level)
{
if(list.containsKey(ip[level]))
{
if(level < ip.length - 1)
{
return isBlocked(list.get(ip[level]).getList(), ip, level + 1);
}
else
{
return true;
}
}
else
{
return false;
}
}
/**
* Getter for list
* @return
*/
protected Map<Integer, IPFilter> getList() {
return filter;
}
}
Solución
Perfílelo a través de algunos casos de uso típicos y use esos datos para descubrir dónde están los cuellos de botella de rendimiento. ENTONCES , optimice ese código.
Sin saber realmente dónde está el problema de rendimiento, podría pasar mucho tiempo y esfuerzo ahorrando microsegundos.
Otros consejos
No estoy seguro de qué es exactamente lo que estás tratando de optimizar. Sin embargo, tiene un par de contieneKey
seguido de get
. Una posible optimización es usar get
y comparar con null
. Por ejemplo, en lugar de:
if (filter.containsKey(ip[level])) {
filter.get(ip[level])
}
Haga lo siguiente:
IPFilter value = filter.get(ip[level]);
if (value != null) {
value.addIp(...);
}
Pero creo que el mejor consejo que puedo darle es: use un generador de perfiles. Si está utilizando Eclipse, marque TPTP .
No por nada, pero una dirección IP es un entero de 4 bytes, ya que generalmente se implementa. ¿Por qué no codificar a eso y simplemente dejar:
int ipSrc = convertIpToInt(String ip);
if ( ipSrc == ipDest ) {
///
}
sea su comparación.
Y para IPv6, puede usar use long.
Por otra parte, lo que probablemente haría es usar java.net.Inet4Address y almacenarlos en un Set.
Dado que ya está utilizando un Mapa, ¿por qué no probar un enfoque simplista? Una implementación inteligente a medias de Inet4Address.equals () haría una comparación de enteros, y no una comparación de cadenas.
Por supuesto, este método se desglosa si desea hacer un comodín ...: - /