Java-web中利用RSA进行加密解密操作的方法示例

前言

最近在看,网络安全方面的问题,我们可以使用RSA进行非对称加密防止,获取用户信息。首先我们看下java下操作RSA进行加密解密算法,代码如下:

package com.jb.test;

import java.security.InvalidKeyException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;

import org.apache.commons.codec.binary.Hex;

public class RSAEntry {

 /**
 * @Title: main
 * @Description: RSA加密算法,解密算法
 * @param args
 * void
 * @throws NoSuchAlgorithmException
 * @throws NoSuchPaddingException
 * @throws InvalidKeyException
 * @throws BadPaddingException
 * @throws IllegalBlockSizeException
 *
 * @throws
 */
 public static void main(String[] args) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
// Security.getProviders();//获取所有支持的加密算法
 //采用非对称加密解密算法
 //生成密钥实例
 KeyPairGenerator keygen = KeyPairGenerator.getInstance("RSA");
 SecureRandom random = new SecureRandom();
 random.setSeed(System.currentTimeMillis());//设置随机种子
 keygen.initialize(512, random);//设置密钥长度,应为64的整数倍
 //生成密钥公钥对
 KeyPair keyPair = keygen.generateKeyPair();
 //获取公钥
 PublicKey pubkey = keyPair.getPublic();
 //获取私钥
 PrivateKey prikey = keyPair.getPrivate();
 //测试数据
 String data = "测试数据";
 //使用公钥进行加密
 //构建加密解密类
 Cipher cipher = Cipher.getInstance("RSA");
 cipher.init(Cipher.ENCRYPT_MODE, pubkey);//设置为加密模式
 byte[] jmdata = cipher.doFinal(data.getBytes());
 //打印加密后数据
 System.out.println(new String(Hex.encodeHex(jmdata)));
 //改为解密模式进行解密
 cipher.init(Cipher.DECRYPT_MODE, prikey);//会用私钥解密
 jmdata = cipher.doFinal(jmdata);
 System.out.println(new String(jmdata));

 }
}

在web应用中,我们可以通过js进行前端加密,java进行后台解密,已达到我们的目的。这里需要注意的是,要想实现正确的加密解密算法,需要使用bcprov-ext-jdk15on-147.jar。

首先创建系统的密钥提供者:

package com.jb.test;

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;

import org.apache.commons.codec.binary.Hex;
import org.bouncycastle.jcajce.provider.asymmetric.rsa.BCRSAPublicKey;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

/**
 * RSA初始化类
 * @author nmm
 * 结合前台的js使用的话,主要需要指定密钥提供者,即引入bcprov-ext-jdk15on-147.jar并使用其中的提供者
 */
public class RsaInitUtil {

 private static KeyPair keyPair;

 private static RsaInitUtil util;

 private RsaInitUtil(){
 try {
 if(keyPair == null) {
 //如果想要能够解密js的加密文件,使用此提供者是必须的
 KeyPairGenerator keygen = KeyPairGenerator.getInstance("RSA", new BouncyCastleProvider());
 SecureRandom random = new SecureRandom();
 random.setSeed(System.currentTimeMillis());
 keygen.initialize(512, random);//设置512位长度
 keyPair = keygen.generateKeyPair();
 }
 } catch (Exception e) {
 e.printStackTrace();
 }
 }

 public static RsaInitUtil getInstance(){
 synchronized ("rsa") {
 if(util == null) {
 util = new RsaInitUtil();
 }
 }
 return util;
 }

 /**
 *
 * 功能说明:[获取公钥]
 * @return
 * 创建者:Nmm, Aug 19, 2013
 */
 public PublicKey getPublicKey(){
 return keyPair.getPublic();
 }

 public PrivateKey getPrivateKey(){
 return keyPair.getPrivate();
 }

 /**
 *
 * 功能说明:[获取公钥字符串]
 * @return
 * 创建者:Nmm, Aug 19, 2013
 */
 public String getPublicKeyStr(){
 //根据我们的提供者,这里获取的是该类型公钥
 BCRSAPublicKey pk = (BCRSAPublicKey) getPublicKey();
 String str = new String(Hex.encodeHex(pk.getModulus().toByteArray()));
 System.out.println(str);
 //获取入口10001一般都为这个
 String ss = new String(Hex.encodeHex(pk.getPublicExponent().toByteArray()));
 //获取转换字符串
 System.out.println(b2Hex(pk.getModulus().toByteArray()));
 return ss + str;
 }
 /**
 *
 * 功能说明:[手动转换]
 * @param byteArray
 * @return
 * 创建者:Nmm, Aug 19, 2013
 */
 private String b2Hex(byte[] byteArray) {
 StringBuilder sb = new StringBuilder();
 for(int i = 0; i < byteArray.length; i++ ) {
 int zhz = byteArray[i];
 if(zhz < 0) {
 zhz += 256;
 }
 if(zhz < 16) {
 sb.append("0");
 }
 sb.append(Integer.toHexString(zhz));
 }
 return sb.toString();
 }
}

前台引入RSA.js,BigInt.js和Barrett.js并采用如下方法加密:

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@page import="com.jb.test.RsaInitUtil"%>
<%

 RsaInitUtil rsa = RsaInitUtil.getInstance();
 String my = rsa.getPublicKeyStr();
 String exp = my.substring(0,6);
 String mou = my.substring(6);
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
 <head>
 <title>RSA测试</title>
 <script type="text/javascript" src="RSA.js"></script>
 <script type="text/javascript" src="BigInt.js"></script>
 <script type="text/javascript" src="Barrett.js"></script>
 </head>

 <body>
 </body>
</html>
<script type="text/javascript">

 var m = '<%=mou%>';
 var e = '<%=exp%>';

 var key = '';
 setMaxDigits(128);
 alert(e);
 key = new RSAKeyPair(e,'',m);
 var res = encryptedString(key,encodeURIComponent('测试数据'));

 window.location.href = 'rsaDecTry.do?res=' + res;

</script>

后台解密算法为:

package com.jb.test;

import java.net.URLDecoder;
import java.security.NoSuchAlgorithmException;

import javax.crypto.Cipher;
import javax.crypto.NoSuchPaddingException;

import org.apache.commons.codec.binary.Hex;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * Rsa加密的控制层
 * @author nmm
 *
 */
@Controller("rsaController")
public class RsaController {

 private RsaInitUtil rsaUtil = RsaInitUtil.getInstance();

 /**
 *
 * 功能说明:[解密方法]
 * @param res
 * 创建者:Nmm, Aug 19, 2013
 * @throws NoSuchPaddingException
 * @throws NoSuchAlgorithmException
 */
 @RequestMapping("rsaDecTry.do")
 public void decodeTry(String res) throws Exception {
 Cipher cipher = Cipher.getInstance("RSA",new BouncyCastleProvider());//必须指定此提供者
 cipher.init(Cipher.DECRYPT_MODE, rsaUtil.getPrivateKey());
 System.out.println(res);
 byte[] buff = cipher.doFinal(Hex.decodeHex(res.toCharArray()));
 //将字符串转为字符
 StringBuilder sb = new StringBuilder(new String(buff,"UTF-8"));
 //解密后的内容是倒叙的
 sb.reverse();
 //进行URL解密,主要是为了中文乱码问题
 String result = URLDecoder.decode(sb.toString(), "UTF-8");
 System.out.println(result);

 }
}

至此可完成,整个加密解密过程,下面大家可以把rsa相关的内容全部整合到一个工具类中,不用想这里处理。

下面为RSA加密解密工具类:

package com.jb.framework.filter;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.math.BigInteger;
import java.net.URLDecoder;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.RSAPublicKeySpec;
import java.util.Calendar;

import javax.crypto.Cipher;

import org.apache.commons.codec.binary.Hex;
import org.bouncycastle.jcajce.provider.asymmetric.rsa.BCRSAPublicKey;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

/**
 *
 * @Package: com.jb.framework.filter<br>
 * @ClassName: RSAUtil<br>
 * @Description: RSA加密工具类,这里我们是每次系统启动时声称一套公钥,私钥,因此不能将加密串存入数据库中,如果要这么做可以预先生成密钥队写入到文件中<br>
 */
public class RSAUtil {

 private RSAUtil(){}

 public static final String keyPubFile = "rsaPubKey.bin";
 public static final String keyPriFile = "rsaPriKey.bin";

 private static RSAUtil rsa;
 //密钥生成器
 private PublicKey publicKey;
 //密钥队
 private PrivateKey privateKey; 

 public static RSAUtil getInstance(){
 synchronized ("rsa") {
 if(rsa == null) {
 rsa = new RSAUtil();
 rsa.init();
 }
 }
 return rsa;
 }
 /**
 *
 * @Title: init
 * @Description: 初始化方法
 * void
 * @throws
 */
 private void init() {
 //构建RSA算法
 try {
 KeyPairGenerator kengen = KeyPairGenerator.getInstance("RSA",new BouncyCastleProvider());
 //构建随机种子
 SecureRandom random = new SecureRandom();
 random.setSeed(Calendar.getInstance().getTimeInMillis());
 kengen.initialize(512, random);//采用512位加密
 KeyPair keyPair = kengen.generateKeyPair();
 publicKey = keyPair.getPublic();
 privateKey = keyPair.getPrivate();
 } catch (NoSuchAlgorithmException e) {
 e.printStackTrace();
 }
 }
 /**
 *
 * @Title: getPublicKey
 * @Description: 获取公钥
 * @return
 * PublicKey
 * @throws
 */
 public PublicKey getPublicKey(){
 return this.publicKey;
 }
 /**
 *
 * @Title: getPrivateKey
 * @Description: 获取私钥
 * @return
 * PrivateKey
 * @throws
 */
 public PrivateKey getPrivateKey(){
 return this.privateKey;
 }
 /**
 *
 * @Title: getPublicKeyStr
 * @Description: 获取系统公钥字符串,前6位为exponentk,后面为modlus
 * @return
 * String
 * @throws
 */
 public String getPublicKeyStr(){
 BCRSAPublicKey pk = (BCRSAPublicKey) getPublicKey();
 String pubStr = "";
 pubStr += b2hex(pk.getPublicExponent().toByteArray());
 pubStr += b2hex(pk.getModulus().toByteArray());
 return pubStr;
 }
 /**
 *
 * @Title: entryText
 * @Description: 使用默认公钥进行加密
 * @param text
 * @return
 * String
 * @throws
 */
 public String encryText(String text) {
 return encryText(text,getPublicKey());
 }
 /**
 *
 * @Title: entryText
 * @Description: 使用指定公钥进行加密,解决长字符串加密
 * @param text
 * @param publicKey2
 * @return
 * String
 * @throws
 */
 public String encryText(String text, PublicKey pk) {
 try {
 Cipher cipher = Cipher.getInstance("RSA",new BouncyCastleProvider());
 cipher.init(Cipher.ENCRYPT_MODE, pk);
 int block = cipher.getBlockSize();//获取最大加密块
 int j = 0;
 StringBuilder sb = new StringBuilder();
 byte[] targetData = text.getBytes("UTF-8");
 while (targetData.length - j*block > 0) {
 byte[] jmdata = cipher.doFinal(targetData,j*block,Math.min(targetData.length - j*block, block));
 sb.append(b2hex(jmdata));
 j++;
 }
 return sb.toString();
 } catch (Exception e) {
 e.printStackTrace();
 }
 return null;
 }
 /**
 *
 * @Title: decryText
 * @Description: 使用默认的私钥进行解密解密算法
 * @param text
 * @return
 * String
 * @throws
 */
 public String decryText(String text) {
 return decryText(text,getPrivateKey());
 }
 /**
 *
 * @Title: decryText
 * @Description: 指定私钥进行解密,增加对于大字符串的解密操作
 * @param text
 * @param privateKey2
 * @return
 * String
 * @throws
 */
 public String decryText(String text, PrivateKey pk) {
 try {
 Cipher cipher = Cipher.getInstance("RSA", new BouncyCastleProvider());
 cipher.init(Cipher.DECRYPT_MODE, pk);
 byte[] targetBuff = Hex.decodeHex(text.replace(" ", "").toCharArray());
 int block = cipher.getBlockSize();
 int j = 0;
 StringBuilder sb = new StringBuilder();
 while (targetBuff.length - j * block > 0) {
 byte[] jmdata = cipher.doFinal(targetBuff,j*block,block);
 sb.append(new String(jmdata,"UTF-8"));
 j++;
 }
 return sb.toString();

 } catch (Exception e) {
 e.printStackTrace();
 }
 return null;
 }
 /**
 *
 * @Title: decryTextByUrl
 * @Description: 解密前台传递的加密串,为防止中文乱码,前台字符串最好使用encodeURIComponent方法进行url编码
 * @param text
 * @return
 * String
 * @throws
 */
 public String decryTextByUrl(String text) {
 try {
 Cipher cipher = Cipher.getInstance("RSA", new BouncyCastleProvider());
 cipher.init(Cipher.DECRYPT_MODE, getPrivateKey());
 byte[] targetBuff = Hex.decodeHex(text.replace(" ", "").toCharArray());
 int block = cipher.getBlockSize();
 int j = 0;
 StringBuilder sb = new StringBuilder();
 while (targetBuff.length - j * block > 0) {//处理大字符串的加密解密处理
 byte[] jmdata = cipher.doFinal(targetBuff,j*block,block);
 sb.append(new StringBuilder(new String(jmdata,"UTF-8")).reverse());
 j++;
 }
 String res = URLDecoder.decode(sb.toString(), "UTF-8");
 return res;

 } catch (Exception e) {
 e.printStackTrace();
 }
 return null;
 }
 /**
 *
 * @Title: createPubKey
 * @Description: 根据指定的幂和模式生成公钥
 * @param exponent
 * @param modules
 * @return
 * PublicKey
 * @throws
 */
 public PublicKey createPubKey(byte[] exponent,byte[]modules) {
 try {
 KeyFactory keyFactory = KeyFactory.getInstance("RSA", new BouncyCastleProvider());
 RSAPublicKeySpec rsaKs = new RSAPublicKeySpec(new BigInteger(modules),new BigInteger(exponent));
 return keyFactory.generatePublic(rsaKs);

 } catch (Exception e) {
 e.printStackTrace();
 }

 return null;
 }
 /**
 *
 * @Title: createPubKey
 * @Description: 根据指定的幂和模式生成公钥
 * @param exponent
 * @param modules
 * @return
 * PublicKey
 * @throws
 */
 public PrivateKey createPriKey(byte[] exponent,byte[]modules) {
 try {
 KeyFactory keyFactory = KeyFactory.getInstance("RSA", new BouncyCastleProvider());
 RSAPrivateKeySpec rsaKs = new RSAPrivateKeySpec(new BigInteger(modules),new BigInteger(exponent));
 return keyFactory.generatePrivate(rsaKs);

 } catch (Exception e) {
 e.printStackTrace();
 }
 return null;
 }
 /**
 *
 * @Title: saveKeyToFile
 * @Description: 保存公钥和私钥到文件中
 * void
 * @throws
 */
 public void saveKeyToFile() {
 PublicKey pk = getPublicKey();
 PrivateKey prik = getPrivateKey();

 String path = RSAUtil.class.getClassLoader().getResource("").getPath();
 ObjectOutputStream outPub = null;
 ObjectOutputStream outPri = null;
 try {
 System.out.println(path + keyPubFile);
 outPub = new ObjectOutputStream(new FileOutputStream(path + keyPubFile));
 outPri = new ObjectOutputStream(new FileOutputStream(path + keyPriFile));
 outPub.writeObject(pk);
 outPri.writeObject(prik);
 } catch (Exception e) {
 e.printStackTrace();
 }finally {
 try {
 outPub.close();
 outPri.close();
 } catch (IOException e) {
 e.printStackTrace();
 }

 }
 }
 /**
 *
 * @Title: readKey
 * @Description: 读取密钥
 * @param isPub
 * @return
 * Object
 * @throws
 */
 public Object readKey(boolean isPub) {
 String path = RSAUtil.class.getClassLoader().getResource("").getPath();
 ObjectInputStream in = null;
 try {
 if(isPub) {
 path += keyPubFile;
 in = new ObjectInputStream(new FileInputStream(path));
 PublicKey pk = (PublicKey) in.readObject();
 return pk;
 }else {
 path += keyPriFile;
 in = new ObjectInputStream(new FileInputStream(path));
 PrivateKey pk = (PrivateKey) in.readObject();
 return pk;
 }
 } catch (Exception e) {
 e.printStackTrace();
 }finally {
 try {
 in.close();
 } catch (IOException e) {
 e.printStackTrace();
 }
 }
 return null;
 }

 /**
 *
 * @Title: b2hex
 * @Description: 将二进制转为16进制字符串
 * @param buff
 * @return
 * String
 * @throws
 */
 public String b2hex(byte[] buff) {
 StringBuilder sb = new StringBuilder();
 for(int i = 0; i < buff.length; i++) {
 int z = buff[i];
 if(z < 0) {
 z+= 256;
 }
 if(z < 16) {
 sb.append("0");
 }
 sb.append(Integer.toHexString(z));
 }
 return sb.toString();
 }
}

下载:http://xiazai.jb51.net/201808/yuanma/rsajar_jb51.rar

总结

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,如果有疑问大家可以留言交流,谢谢大家对我们的支持。

(0)

相关推荐

  • java使用RSA加密方式实现数据加密解密的代码

    RSA的应用 RSA是一种非对称加密算法.现在,很多登陆表单的密码的都采用RSA加密,例如京东中的登陆使用公钥对密码进行加密 java使用RSA加密方式实现数据加密解密,需要首先产生私钥和公钥 测试代码 public static void main(String args[]) { try { RSADemo rsa=new RSADemo(); rsa.generateKey(); byte[] data=rsa.encrypt("luanpeng".getBytes()); by

  • Java实现的RSA加密解密算法示例

    本文实例讲述了Java实现的RSA加密解密算法.分享给大家供大家参考,具体如下: import java.awt.AlphaComposite; import java.awt.Color; import java.awt.Font; import java.awt.Graphics2D; import java.awt.Image; import java.awt.RenderingHints; import java.awt.image.BufferedImage; import java.

  • java 加密之RSA算法加密与解密的实例详解

    java 加密之RSA算法加解密与解密的实例详解 前言: RSA是第一个比较完善的公开密钥算法,它既能用于加密,也能用于数字签名.RSA以它的三个发明者Ron Rivest, Adi Shamir, Leonard Adleman的名字首字母命名,这个算法经受住了多年深入的密码分析,虽然密码分析者既不能证明也不能否定RSA的安全性,但这恰恰说明该算法有一定的可信性,目前它已经成为最流行的公开密钥算法. RSA的安全基于大数分解的难度.其公钥和私钥是一对大素数(100到200位十进制数或更大)的函

  • java使用RSA与AES加密解密的实例代码详解

    首先了解下,什么是堆成加密,什么是非对称加密? 对称加密:加密与解密的密钥是相同的,加解密速度很快,比如AES 非对称加密:加密与解密的秘钥是不同的,速度较慢,比如RSA •先看代码(先会用在研究) 相关依赖: <dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcprov-jdk15on</artifactId> <version>1.58</versio

  • Java中RSA加密解密的实现方法分析

    本文实例讲述了Java中RSA加密解密的实现方法.分享给大家供大家参考,具体如下: public static void main(String[] args) throws Exception { // TODO Auto-generated method stub HashMap<String, Object> map = RSAUtils.getKeys(); //生成公钥和私钥 RSAPublicKey publicKey = (RSAPublicKey) map.get("

  • java加密算法分享(rsa解密、对称加密、md5加密)

    复制代码 代码如下: import java.io.UnsupportedEncodingException;import java.security.InvalidKeyException;import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;import java.security.PrivateKey;import java.security.PublicKey;import jav

  • JAVA 中解密RSA算法JS加密实例详解

    JAVA 中解密RSA算法JS加密实例详解 有这样一个需求,前端登录的用户名密码,密码必需加密,但不可使用MD5,因为后台要检测密码的复杂度,那么在保证安全的前提下将密码传到后台呢,答案就是使用RSA非对称加密算法解决 . java代码 需要依赖 commons-codec 包 RSACoder.Java import org.apache.commons.codec.binary.Base64; import javax.crypto.Cipher; import java.security.

  • Java RSA加密解密实现方法分析【附BASE64 jar包下载】

    本文实例讲述了Java RSA加密解密实现方法.分享给大家供大家参考,具体如下: 该工具类中用到了BASE64,需要借助第三方类库:javabase64-1.3.1.jar javabase64-1.3.1.jar 本站下载地址. 注意: RSA加密明文最大长度117字节,解密要求密文最大长度为128字节,所以在加密和解密的过程中需要分块进行. RSA加密对明文的长度是有限制的,如果加密数据过大会抛出如下异常: Exception in thread "main" javax.cryp

  • Java-web中利用RSA进行加密解密操作的方法示例

    前言 最近在看,网络安全方面的问题,我们可以使用RSA进行非对称加密防止,获取用户信息.首先我们看下java下操作RSA进行加密解密算法,代码如下: package com.jb.test; import java.security.InvalidKeyException; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.NoSuchAlgorithmExcepti

  • python中pandas库中DataFrame对行和列的操作使用方法示例

    用pandas中的DataFrame时选取行或列: import numpy as np import pandas as pd from pandas import Sereis, DataFrame ser = Series(np.arange(3.)) data = DataFrame(np.arange(16).reshape(4,4),index=list('abcd'),columns=list('wxyz')) data['w'] #选择表格中的'w'列,使用类字典属性,返回的是S

  • Java Web项目部署在Tomcat运行出错与解决方法示例

    本文实例讲述了Java Web项目部署在Tomcat运行出错与解决方法.分享给大家供大家参考,具体如下: 1.在部署Java Web项目的过程中,启动Tomcat出现报错提示 具体报错如下: Could not load the Tomcat server configuration at \Servers\Tomcat v7.0 Server at localhost-config. The configuration may be corrupt or incomplete. 元素类型 "H

  • Java Web中解决路径(绝对路径与相对路径)问题

    Java Web中解决路径问题: Java中使用的路径,分为两种:绝对路径和相对路径.归根结底,Java本质上只能使用绝对路径来寻找资源.所有的相对路径寻找资源的方法,都不过是一些便利方法.不过是API在底层帮助我们构建了绝对路径,从而找到资源的! 在开发Web方面的应用时, 经常需要获取 服务器中当前WebRoot的物理路径. 如果是Servlet , Action , Controller, 或则Filter , Listener , 拦截器等相关类时, 我们只需要获得ServletCont

  • php中base64_decode与base64_encode加密解密函数实例

    本文实例讲述了php中base64_decode与base64_encode加密解密函数.分享给大家供大家参考.具体分析如下: 这两个函数在php中是用得对php代码进行加密与解密码的base64_encode是加密,而base64_decode是解密了,下面我们看两个简单实例. base64_encode语法:string base64_decode(string data); 复制代码 代码如下: $str='d3d3LmpiNTEubmV0IOiEmuacrOS5i+Wutg==';   

  • java web中图片验证码功能的简单实现方法

    用户在注册网站信息的时候基本上都要数据验证码验证.那么图片验证码功能该如何实现呢? 大概步骤是: 1.在内存中创建缓存图片 2.设置背景色 3.画边框 4.写字母 5.绘制干扰信息 6.图片输出 废话不多说,直接上代码 package com.lsgjzhuwei.servlet.response; import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.image.Buffer

  • java中利用反射调用另一类的private方法的简单实例

    我们知道,Java应用程序不能访问持久化类的private方法,但Hibernate没有这个限制,它能够访问各种级别的方法,如private, default, protected, public. Hibernate是如何实现该功能的呢?答案是利用JAVA的反射机制,如下: import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public class ReflectDemo {

  • JSP学习之Java Web中的安全控制实例详解

    本文实例讲述了JSP学习之Java Web中的安全控制.分享给大家供大家参考.具体如下: 一.目标: ① 掌握登录之后的一般处理过程: ② 能够为每个页面添加安全控制: ③ 能够共享验证代码: ④ 使用过滤器对权限进行验证: ⑤ 能够对文件的局部内容进行验证: ⑥ 掌握安全验证码的基本实现方式: ⑦ 通过异常处理增强安全性. 二.主要内容: ① 通过修改前面的登录功能,分别对管理员和普通用户的登录进行处理: ② 为管理员才能访问的页面添加控制: ③ 共享各个页面中的控制代码,使用专门的文件,然后

  • Java Web中常用的分页组件(Java端实现)

     前言 好久没写Web程序了,这一段时间看了看原来师弟们做的一些程序,感觉还是有很多不足,一个比较典型的例子就是分页查询的实现,正好借着这个机会简单记录一下. 分析 使用场景 "分页"在Web程序里非常常见,比如我们在页面上经常要展示一些列表信息,通常情况下,如果数据过多,我们在一屏上难以罗列出所有的记录,而且很多时候我们可能只是看看比较Top的一些记录,因此,在这种情况下使用"分页"查询只展示部分数据是比较合适的. 实现原理 从数据库角度上来说,分页查询实现的难度

随机推荐