Java 方法性能
当我单独使用一个类调用某个方法时，平均需要11523纳秒（10000次调用），但当我从另一个类的上下文调用它时，大约需要95721秒 方法主体是Java 方法性能,java,Java,当我单独使用一个类调用某个方法时，平均需要11523纳秒（10000次调用），但当我从另一个类的上下文调用它时，大约需要95721秒 方法主体是 public static byte [] validateRequest(KARPPacket karpPacket) { try { long before,time; before =System.nanoTime(); byte [] encryptedTicket=karpPacket.getTicket();
public static byte [] validateRequest(KARPPacket karpPacket)
{
try {
long before,time;
before =System.nanoTime();
byte [] encryptedTicket=karpPacket.getTicket();
byte[] decryptedTicket=null;
if(encryptedTicket==null)
return null;
if(encryptedTicket.length%16==0)
{
decryptedTicket = Encryptor.decrypt(encryptedTicket, ClientWindow.getSecretKey());
time=System.nanoTime()-before;
System.out.println(time);
if(karpPacket.getSenderProtocolAddressAsString().equals(getSrcAddressFromTicket(decryptedTicket)))
{
ClientTicketManager.getArpCash().put(karpPacket.getSenderProtocolAddressAsString(), karpPacket.getSenderHardwareAddressFormatted());
return decryptedTicket;
}
return decryptedTicket;
}
return null;
} catch (Exception e) {
e.printStackTrace();
return null;
}
public static byte[] decrypt(byte [] encryptedByteArray,String keyString)throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException,
IllegalBlockSizeException, BadPaddingException
{
SecretKey key=loadKey(keyString);
byte[] clearByteArray;
Cipher dCipher=Cipher.getInstance("AES");
dCipher.init(Cipher.DECRYPT_MODE,key );
clearByteArray=dCipher.doFinal(encryptedByteArray);
return clearByteArray;
public static SecretKey loadKey(String keyString) {
byte[] encoded = keyString.getBytes();
SecretKey key = new SecretKeySpec(encoded, "AES");
return key;
}
package karp.client;
import java.awt.Color;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.sql.Timestamp;
import java.util.Date;
import javax.crypto.BadPaddingException;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.swing.JOptionPane;
import javax.swing.text.Style;
import javax.swing.text.StyleConstants;
import javax.swing.text.StyledDocument;
import karp.client.presentation.ClientWindow;
import karp.client.util.Constants;
import karp.generalutil.common.Encryptor;
import karp.generalutil.destination.TicketDestination;
import karp.packet.KARPPacket;
public class KARPMessageHandlerP {
String localIpAddress=null;
ClientTicketManager clientTicketManager;
KARPSender karpRequestSender=new KARPSender();
byte [] srcMac;
NetworkInterface network;
public KARPMessageHandlerP(KARPPacket karpPacket)
{
try
{
long before,time;
localIpAddress=KARPReciever.localIpAddress;
clientTicketManager=KARPReciever.clientTicketManager;
srcMac = KARPReciever.srcMac;
//
if(karpPacket.getOperation()==KARPPacket.ARP_REPLY)
{
if(karpPacket.getSenderProtocolAddressAsString().equals(localIpAddress))//request sent by client
{
// if the reply was sent by the client no action must be taken.
}
else
{
if(karpPacket.getTargetProtocolAddressAsString().equals(localIpAddress))
{
byte [] ticket=karpPacket.getTicket();
if(ticket==null)
{
//delete the new entry from cash and refresh the cash
deleteEntry(karpPacket.getSenderProtocolAddressAsString());
}
else
{
if(validateReply(karpPacket) )
{
}
else
{
deleteEntry(karpPacket.getSenderProtocolAddressAsString());
//delete entry and refresh cash
}
}
}
}
}
else
if(karpPacket.getOperation()==KARPPacket.ARP_REQUEST)
{
if(karpPacket.getSenderProtocolAddressAsString().equals(localIpAddress))//request sent by client
{
//1
if(karpPacket.getTicket()!=null)
{
//custom request no need to add;
}
//2
else //new request need to add ticket
{
String destinationId=(karpPacket.getTargetProtocolAddressAsString());
// if the map contain ticket to destination add the ticket directly
//2-1
KARPPacket customKarpPacket;
byte [] ticketDestinationByte=null;
if(ClientTicketManager.getDestinationTicketMap().containsKey(destinationId))
{
ticketDestinationByte=ClientTicketManager.getDestinationTicketMap().get(destinationId);
}
//2-2 send ticket request
else
{
ticketDestinationByte=clientTicketManager.getDestinationTicket(destinationId);
}
if(ticketDestinationByte!=null)
{
customKarpPacket= karpRequestSender.createKARPPacket(karpPacket.getDstAddress(), karpPacket.getSrcAddress(),
InetAddress.getLocalHost().getAddress(), karpPacket.getTargetProtoAddr(),
karpPacket.getTargetHardAddr(),
ticketDestinationByte, KARPPacket.ARP_REQUEST);
karpRequestSender.sendKARPPacket(customKarpPacket);
}
}
}
else
{
if(karpPacket.getTargetProtocolAddressAsString().equals(localIpAddress))//check to see if the request is for the client
{
byte [] ticketRequest=validateRequest(karpPacket);
if(ticketRequest!=null)
{
//reply to the request;
String sessionKey=getSessionKeyFromTicket(ticketRequest);
TicketDestination ticketDestination=new TicketDestination();
ticketDestination.setDestinationId(karpPacket.getSenderProtocolAddressAsString());
ticketDestination.setSourceId(karpPacket.getTargetProtocolAddressAsString());
ticketDestination.setSourceDestinationKey(sessionKey);
byte [] ticketDestinationByte=ticketDestination.getAsByte();
byte [] encryptedTicketDestination=Encryptor.encrypt(ticketDestinationByte, sessionKey);
///need to review target hardware address
KARPPacket karpPacketReply=karpRequestSender.createKARPPacket(karpPacket.getSrcAddress(), srcMac, InetAddress.getLocalHost().getAddress(), karpPacket.getSenderProtoAddr(),karpPacket.getSrcAddress(), encryptedTicketDestination, KARPPacket.ARP_REPLY);
karpRequestSender.sendKARPPacket(karpPacketReply);
}
else //delete ticket invalid request
{
deleteEntry(karpPacket.getSenderProtocolAddressAsString());
}
}
}
}
}
catch(Exception e)
{
e.printStackTrace();
}
//System.out.println(timeConsumed);
}
public static byte [] validateRequest(KARPPacket karpPacket)
{
try {
long before,time;
before =System.nanoTime();
byte [] encryptedTicket=karpPacket.getTicket();
byte[] decryptedTicket=null;
if(encryptedTicket==null)
return null;
if(encryptedTicket.length%16==0)
{
decryptedTicket = Encryptor.decrypt(encryptedTicket, ClientWindow.getSecretKey());
time=System.nanoTime()-before;
System.out.println(time);
if(karpPacket.getSenderProtocolAddressAsString().equals(getSrcAddressFromTicket(decryptedTicket)))
{
ClientTicketManager.getArpCash().put(karpPacket.getSenderProtocolAddressAsString(), karpPacket.getSenderHardwareAddressFormatted());
return decryptedTicket;
}
return decryptedTicket;
}
return null;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public boolean validateReply(KARPPacket karpPacket) throws InvalidKeyException, NoSuchAlgorithmException,
NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException
{
// KARPReciever.stop=true;
// for(int i=0;i<10000;i++)
// {
String sessionKey;
byte[] encryptedTicket=karpPacket.getTicket();
if(ClientTicketManager.getDestinationKeyMap().containsKey(karpPacket.getSenderProtocolAddressAsString()))
{
sessionKey=ClientTicketManager.getDestinationKeyMap().get(karpPacket.getSenderProtocolAddressAsString());
byte[] decryptedTicket=Encryptor.decrypt(encryptedTicket, sessionKey);
if(karpPacket.getSenderProtocolAddressAsString().equals(getSrcAddressFromTicket(decryptedTicket)))
{
ClientTicketManager.getArpCash().put(karpPacket.getSenderProtocolAddressAsString(), karpPacket.getSenderHardwareAddressFormatted());
// after=System.nanoTime();
// timeConsumed=(after-before);
// System.out.print("kl"+timeConsumed);
return true;
}
}
//}
return false;
}
public void deleteEntry(String entryIpAddress)
{
try
{
if(!ClientTicketManager.getAuthenticatedUser().contains(entryIpAddress))
{
if(ClientTicketManager.getArpCash().containsKey(entryIpAddress))
{
String updateCommand="arp -s "+entryIpAddress+" "+clientTicketManager.getArpCash().get(entryIpAddress);
//printCash();
Runtime.getRuntime().exec(updateCommand);
}
else
{
String deleteCommand ="arp -d "+entryIpAddress;
Runtime.getRuntime().exec(deleteCommand);
}
}
}
catch(Exception e)
{
}
}
public static String getSrcAddressFromTicket(byte [] ticket)
{
byte [] srcByte=new byte[4];
System.arraycopy(ticket, 16, srcByte, 0, 4);
String srcString=TicketDestination.getIpAddressAsString(srcByte);
return srcString;
}
public String getSessionKeyFromTicket(byte [] ticket)
{
byte [] sessionKeyByte=new byte[16];
System.arraycopy(ticket, 0, sessionKeyByte,0, 16);
return new String(sessionKeyByte);
}
public void printCash()
{
for(Object entry:ClientTicketManager.getArpCash().entrySet().toArray())
{
System.out.println(entry+" "+clientTicketManager.getArpCash().get(entry)+" entry in cash ");
}
}
}
packarp.client；
导入java.awt.Color；
导入java.net.Inet4Address；
导入java.net.InetAddress；
导入java.net.NetworkInterface；
导入java.security.InvalidKeyException；
导入java.security.NoSuchAlgorithmException；
导入java.sql.Timestamp；
导入java.util.Date；
导入javax.crypto.BadPaddingException；
导入javax.crypto.IllegalBlockSizeException；
导入javax.crypto.NoSuchPaddingException；
导入javax.swing.JOptionPane；
导入javax.swing.text.Style；
导入javax.swing.text.StyleConstants；
导入javax.swing.text.StyledDocument；
导入karp.client.presentation.ClientWindow；
导入karp.client.util.Constants；
导入karp.generalutil.common.Encryptor；
导入karp.generalutil.destination.TicketDestination；
导入karp.packet.KARPPacket；
公共类KARPMessageHandlerP{
字符串localIpAddress=null；
ClientTicketManager客户端TicketManager；
KARPSender karpRequestSender=新的KARPSender（）；
字节[]srcMac；
网络接口网络；
公共KARPMessageHandlerP（KARPPacket-KARPPacket）
{
尝试
{
很久以前，时间；
LocalicPaddress=KARPReciever.LocalicPaddress；
clientTicketManager=KARPReciever.clientTicketManager；
srcMac=karpriciever.srcMac；
//
if（kappacket.getOperation（）==kappacket.ARP_REPLY）
{
if（kappacket.getSenderProtocolAddressAssString（）.equals（localIpAddress））//客户端发送的请求
{
//如果回复是由客户端发送的，则不必采取任何操作。
}
其他的
{
if（kappacket.getTargetProtocolAddressAsString（）.equals（localIpAddress））
{
字节[]票证=kappacket.getTicket（）；
如果（票证==null）
{
//从现金中删除新条目并刷新现金
deleteEntry（karpPacket.getSenderProtocolAddressAsString（））；
}
其他的
{
if（验证层（卡帕凯特））
{
}
其他的
{
deleteEntry（karpPacket.getSenderProtocolAddressAsString（））；
//删除条目并刷新现金
}
}
}
}
}
其他的
if（kappacket.getOperation（）==kappacket.ARP_请求）
{
if（kappacket.getSenderProtocolAddressAssString（）.equals（localIpAddress））//客户端发送的请求
{
//1
if（karpacket.getTicket（）！=null）
{
//自定义请求无需添加；
}
//2
else//新请求需要添加票据
{
字符串destinationId=（kappacket.getTargetProtocolAddressAsString（））；
//如果地图包含到目的地的车票，则直接添加车票
//2-1
卡帕克顾客卡帕克；
字节[]ticketDestinationByte=null；
if（ClientTicketManager.getDestinationTicketMap（）.containsKey（destinationId））
{
ticketDestinationByte=ClientTicketManager.getDestinationTicketMap（）.get（destinationId）；
}
//2-2发送票据请求
其他的
{
ticketDestinationByte=clientTicketManager.GetDestinationICket（destinationId）；
}
if（ticketDestinationByte！=null）
{
customKarpPacket=karpRequestSender.createKARPPacket（karpPacket.getDstAddress（），karpPacket.getSrcAddress（），
InetAddress.getLocalHost（）.getAddress（），kappacket.getTargetProtoAddr（），
karpPacket.getTargetHardAddr（），
ticketDestinationByte、KARPPacket.ARP_请求）；
karpRequestSender.sendKARPPacket（自定义Karppacket）；
}
}
}
其他的
{
if（kappacket.getTargetProtocolAddressAsString（）.equals（localIpAddress））//检查请求是否针对客户端
{
字节[]ticketRequest=validateRequest（karpPacket）；
如果（ticketRequest！=null）
{
//对请求的答复；
字符串sessionKey=getSessionKeyFromTicket（ticketRequest）；
TicketDestination TicketDestination=新的TicketDestination（）；
ticketDestination.setDestinationId（kappacket.getSenderProtocolAddressAssString（））；
ticketDestination.setSourceId（kappacket.getTargetProtocolAddressAsString（））；
ticketDestination.setSourceDestinationKey（会话键）；
byte[]ticketDestinationByte=ticketDestination.getAsByte（）；
byte[]encryptedTicketDestination=Encryptor.encrypt（ticketDestinationByte，sessionKey）；
///需要检查目标硬件地址
karpacket karpacketreply=karpRequestSender.createkarpacket（karp