Ottimizzazione del codice Java
-
06-07-2019 - |
Domanda
Come posso ottimizzare questo codice? Ho creato IPFilter e devo ottimizzarlo.
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;
}
}
Soluzione
Profilalo attraverso alcuni casi d'uso tipici e usa quei dati per scoprire dove si trovano i colli di bottiglia delle prestazioni. POI , ottimizza quel codice.
Senza sapere effettivamente dove si trova il problema delle prestazioni, potresti dedicare molto tempo e fatica a risparmiare microsecondi.
Altri suggerimenti
Non sono sicuro di cosa stai esattamente cercando di ottimizzare. Tuttavia, hai un paio di IncludesKey
seguito da get
. Una possibile ottimizzazione consiste nell'utilizzare get
e confrontarlo con null
. Ad esempio, anziché:
if (filter.containsKey(ip[level])) {
filter.get(ip[level])
}
Procedi come segue:
IPFilter value = filter.get(ip[level]);
if (value != null) {
value.addIp(...);
}
Ma penso che il miglior consiglio che posso darti sia: usa un profiler. Se stai usando Eclipse, controlla TPTP .
Non per niente, ma un indirizzo IP è un numero intero di 4 byte come di solito è implementato. Perché non codificarlo, e lascia solo:
int ipSrc = convertIpToInt(String ip);
if ( ipSrc == ipDest ) {
///
}
sii il tuo confronto.
E per IPv6, puoi usare use long.
Quindi, quello che probabilmente farei è usare java.net.Inet4Address e memorizzarli in un set.
Dato che stai già utilizzando una mappa, perché non provare un approccio semplicistico? Un'implementazione intelligente a metà di Inet4Address.equals () farebbe un confronto tra numeri interi e non un confronto di stringhe.
Naturalmente questo metodo si interrompe se si desidera eseguire il jolly ...: - /