hibernate 基础dao类实现2

最新推荐文章于 2024-06-04 09:07:32 发布
最新推荐文章于 2024-06-04 09:07:32 发布
阅读量1.6k 收藏 1
点赞数
文章标签： hibernate dao string list integer session
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wal812834184/article/details/5648034
版权

import java.io.Serializable;
import java.math.BigInteger;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Projections;
import org.springframework.orm.hibernate3.HibernateCallback;

import com.framework.commons.pagination.Page;
import com.framework.commons.pagination.PageConstant;
import com.framework.commons.utils.EntityDao;
import com.framework.commons.utils.ParamValidate;
import com.framework.commons.utils.StringUtils;


/**
 * 负责为单个Entity对象提供CRUD操作的Hibernate DAO基类. <p/> 子类只要在类定义时指定所管理Entity的Class,
 * 即拥有对单个Entity对象的CRUD操作.
 *
 * <pre>
 * public class UserManager extends HibernateEntityDao&lt;User&gt; {
 * }
 * </pre>
 *
 * @author calvin
 * @see HibernateGenericDao
 */
@SuppressWarnings("unchecked")
public abstract class HibernateEntityDao<T> extends HibernateGenericDao
  implements EntityDao<T> {

 protected Class<T> entityClass;

 /**
  * findById
  *
  * @param id
  * @return
  */
 public T findById(Serializable id) {
  return findById(getEntityClass(), id);
 }

 /**
  * 批量删除
  * @param ids
  */
 public void delete(String[] ids) {
  String hql = "delete from " + getEntityClass().getName()
    + " as o where o." + getIdName(getEntityClass()) + " in "
    + StringUtils.createBlock(ids);

  batchUpdate(hql);
 }

 public void delete(long[] ids) {
  String hql = "delete from " + getEntityClass().getName()
    + " as o where o." + getIdName(getEntityClass()) + " in "
    + StringUtils.createBlock(ids);
  batchUpdate(hql);
 }

 public List<T> findById(String[] ids){
  String hql = "from "+getEntityClass().getName()
    + " as o where o."+getIdName(getEntityClass())+" in "
    + StringUtils.createBlock(ids);
  return createHql(hql);
 }
 /**
  *
  * @param ids
  * @return
  */
 public String createBlock(long[] ids) {
  if (ids == null || ids.length == 0)
   return "('')";
  String blockStr = "(";
  for (int i = 0; i < ids.length - 1; i++) {
   blockStr += "'" + ids[i] + "',";
  }
  blockStr += "'" + ids[ids.length - 1] + "')";
  return blockStr;
 }

 /**
  * 批量更新
  * 用于审核,激活等操作
  * @param ids
  * @param property
  * @param value
  */
 public void update(String[] ids, String property, int value) {
  String hql = " update " + getEntityClass().getName() + " set "
    + property + "=" + value + " where "
    + getIdName(getEntityClass()) + " in "
    + StringUtils.createBlock(ids);
  batchUpdate(hql);
 }

 
 /**
  * map (key 为数据库字段 value 为修改的值) ids为空表示修改所有
  * 根据主建批量更新 支持多字段
  * 支持修改字段类型int long String byte
  */
 public void update(long[] ids, Map<String, Object> param) {
  if (param != null) {
   int index = 0;
   StringBuffer hql = new StringBuffer("update "
     + getEntityClass().getName() + " set ");
   Iterator<String> params = param.keySet().iterator();
   while (params.hasNext()) {
    String temp = params.next();
    hql.append(temp + "=? ,");
   }
   hql.deleteCharAt(hql.length() - 1);
   if (ids != null) {
    hql.append("where ");
    for (long id : ids) {
     hql
       .append(getIdName(getEntityClass()) + "=" + id
         + " and ");
    }
   }

   int end = hql.lastIndexOf("and");
   Query query = getSession().createQuery(
     end != -1 ? hql.substring(0, end) : hql.toString());

   params = param.keySet().iterator();
   while (params.hasNext()) {
    String temp = params.next();
    query.setParameter(index, param.get(temp));
    index++;
   }

   query.executeUpdate();
  }
 }
 
 
 
 
 
 
 
 
 
 
 
 /**
  * 获取最大SN序号
  * @return
  */
 public int selectMaxSn() {
  Criteria criteria = getSession().createCriteria(getEntityClass());
  criteria.setProjection(Projections.max("sn"));
  List list = criteria.list();
  if (list == null || list.get(0) == null)
   return 0;
  return (Integer) list.get(0);

 }

 /**
  * HQL分页查询数据
  * @param map 压入一些需要的参数
  * @return
  */
 public List findByPage(final Map map) {
  final int curPageNum = (Integer) map.get(PageConstant.CUR_PAGE_NUM);
  final int pageSize = (Integer) map.get(PageConstant.PAGE_SIZE);
  final String hql = getHql(map);
  final int startIndex = Page.getStartOfPage(curPageNum, pageSize);
  List list = getHibernateTemplate().executeFind(new HibernateCallback() {
   public Object doInHibernate(Session session)
     throws HibernateException, SQLException {
    List result = session.createQuery(hql).setFirstResult(
      startIndex).setMaxResults(pageSize).list();
    return result;
   }
  });
  return list;
 }

 /**
  * HQL分页 查询数据
  * @param map 压入一些需要的参数
  * @param hql 查询语句
  * @return
  */
 public List findByPage(final Map map, StringBuffer hql) {
  List paramList=new ArrayList();
  likeHql(hql, paramList, map);
  map.put(PageConstant.HQL, hql.toString());
  return findByPage(map);
 }

 /**
  * HQL查询所有记录的数量
  * @param map 压入需要的基本参数
  * @return
  */
 public long getRowCount(Map map) {
  final String hql = (String) map.get(PageConstant.HQL);
  long ret = (Long) getHibernateTemplate().execute(
    new HibernateCallback() {
     public Object doInHibernate(Session session)
       throws HibernateException, SQLException {
      return session.createQuery(hql).uniqueResult();
     }
    });
  return ret;
 }

 /**
  * HQL分页 查询数据
  * @param map 压入一些需要的参数
  * @param hql 查询语句
  * @return
  */
 public long getRowCount(Map map, StringBuffer hql) {
  likeHql(hql, null, map);
  map.put(PageConstant.HQL, hql.toString());
  return getRowCount(map);
 }

 /**
  * hql语句进行order by 排序
  * @param map
  * @return
  */
 public String getHql(final Map map) {
  final String orderByField = (String) map
    .get(PageConstant.ORDER_BY_FIELD);
  final String orderByDesc = (String) map.get(PageConstant.ORDER_BY_DESC);
  String hql = (String) map.get(PageConstant.HQL);
  if (ParamValidate.isNotEmpty(orderByField)
    && ParamValidate.isNotEmpty(orderByDesc)) {
   hql += (ParamValidate.isNotEmpty(orderByField) ? " order by "
     + orderByField : "")
     + " " + orderByDesc;
  }
  return hql;
 }

 /**
  * HQL查询分页语句
  * @param map
  * @param objects List 对象 需要传入参数防止注入时使用
  * @return
  */
 public List findByPage(final Map map, final List objects) {
  final int curPageNum = (Integer) map.get(PageConstant.CUR_PAGE_NUM);
  final int pageSize = (Integer) map.get(PageConstant.PAGE_SIZE);
  final String hql = getHql(map);
  final int startIndex = Page.getStartOfPage(curPageNum, pageSize);
  List list = getHibernateTemplate().executeFind(new HibernateCallback() {
   public Object doInHibernate(Session session)
     throws HibernateException, SQLException {
    Query query = createQuery(hql, objects);
    List result = query.setFirstResult(startIndex).setMaxResults(
      pageSize).list();
    return result;
   }
  });
  return list;
 }

 /**
  * 本地查询分页
  * @param map 压入需要的基本参数
  * @return
  */
 public List findBySQLPage(final Map map) {
  final int curPageNum = (Integer) map.get(PageConstant.CUR_PAGE_NUM);
  final int pageSize = (Integer) map.get(PageConstant.PAGE_SIZE);
  final String hql = getHql(map);
  final int startIndex = Page.getStartOfPage(curPageNum, pageSize);
  List list = getHibernateTemplate().executeFind(new HibernateCallback() {
   public Object doInHibernate(Session session)
     throws HibernateException, SQLException {
    List result = session.createSQLQuery(hql).setFirstResult(
      startIndex).setMaxResults(pageSize).list();
    return result;
   }
  });
  return list;
 }

 /**
  * 本地查询分页
  * @param map
  * @param query对象 
  * @return
  */

 public List findByPage(final Map map, final Query query) {
  final int curPageNum = (Integer) map.get(PageConstant.CUR_PAGE_NUM);
  final int pageSize = (Integer) map.get(PageConstant.PAGE_SIZE);
  final int startIndex = Page.getStartOfPage(curPageNum, pageSize);
  List list = getHibernateTemplate().executeFind(new HibernateCallback() {
   public Object doInHibernate(Session session)
     throws HibernateException, SQLException {
    List result = query.setFirstResult(startIndex).setMaxResults(
      pageSize).list();
    return result;
   }
  });
  return list;
 }

 /**
  * 本地查询分页
  * @param map 压入需要的基本参数
  * @param List 对象
  * @return
  */
 public List findBySQLPage(final Map map, final List objects) {
  final int curPageNum = (Integer) map.get(PageConstant.CUR_PAGE_NUM);
  final int pageSize = (Integer) map.get(PageConstant.PAGE_SIZE);
  final String hql = getHql(map);
  final int startIndex = Page.getStartOfPage(curPageNum, pageSize);
  List list = getHibernateTemplate().executeFind(new HibernateCallback() {
   public Object doInHibernate(Session session)
     throws HibernateException, SQLException {
    Query query = createSQLQuery(hql, objects);
    List result = query.setFirstResult(startIndex).setMaxResults(
      pageSize).list();
    return result;
   }
  });
  return list;
 }

 /**
  * 查询所有记录
  */
 public List<T> findAll() {
  return findAll(getEntityClass());
 }

 /**
  * 进行排序
  * @param hql
  * @param map
  * @return query 对象
  */
 public Query getHql(StringBuffer hql, final Map map) {
  map.put(PageConstant.HQL, hql.toString());
  return this.createQuery(getHql(map));
 }

 /**
  * 本地查询分页
  * @param map
  * @return
  */
 public long getRowSQLCount(Map map) {
  final String hql = (String) map.get(PageConstant.HQL);
  ;
  long ret = (Long) getHibernateTemplate().execute(
    new HibernateCallback() {
     public Object doInHibernate(Session session)
       throws HibernateException, SQLException {
      return session.createSQLQuery(hql).uniqueResult();
     }
    });
  return ret;
 }

 /**
  * 在构造函数中将泛型T.class赋给entityClass.
  */
 public HibernateEntityDao() {
  entityClass = com.framework.commons.utils.GenericsUtils
    .getSuperClassGenricType(getClass());
 }

 /**
  * 取得entityClass.JDK1.4不支持泛型的子类可以抛开Class<T> entityClass,重载此函数达到相同效果
  */
 protected Class<T> getEntityClass() {
  return entityClass;
 }

 /**
  * 获取全部对象,带排序参
  *
  * @see HibernateGenericDao#getAll(Class,String,boolean)
  */
 public List<T> findAll(String orderBy, boolean isAsc) {
  return findAll(getEntityClass(), orderBy, isAsc);
 }

 /**
  * 取得Entity的Criteria.
  *
  * @see HibernateGenericDao#createCriteria(Class,Criterion[])
  */
 public Criteria createCriteria(Criterion... criterions) {
  return createCriteria(getEntityClass(), criterions);
 }

 /**
  * 取得Entity的Criteria,带排序参
  *
  * @see HibernateGenericDao#createCriteria(Class,String,boolean,Criterion[])
  */
 public Criteria createCriteria(String orderBy, boolean isAsc,
   Criterion... criterions) {
  return createCriteria(getEntityClass(), orderBy, isAsc, criterions);
 }

 /**
  * 根据属名和属性查询对
  *
  * @return 符合条件的对象列
  * @see HibernateGenericDao#findBy(Class,String,Object)
  */
 public List<T> findBy(String propertyName, Object value) {
  return findBy(getEntityClass(), propertyName, value);
 }

 /**
  * 根据属名和属性查询对,带排序参
  *
  * @return 符合条件的对象列
  * @see HibernateGenericDao#findBy(Class,String,Object,String,boolean)
  */
 public List<T> findBy(String propertyName, Object value, String orderBy,
   boolean isAsc) {
  return findBy(getEntityClass(), propertyName, value, orderBy, isAsc);
 }

 /**
  * 根据属名和属性查询单个对
  *
  * @return 符合条件的唯对象 or null
  * @see HibernateGenericDao#findUniqueBy(Class,String,Object)
  */
 public T findUniqueBy(String propertyName, Object value) {
  return findUniqueBy(getEntityClass(), propertyName, value);
 }

 /**
  * 判断对象某些属的值在数据库中唯一.
  *
  * @param uniquePropertyNames
  *            在POJO里不能重复的属列,以号分割"name,loginid,password"
  * @see HibernateGenericDao#isUnique(Class,Object,String)
  */
 public boolean isUnique(Object entity, String uniquePropertyNames) {
  return isUnique(getEntityClass(), entity, uniquePropertyNames);
 }

 /**
  * hibernate批量更新--(删除/修改)
  *
  * @param hql
  */
 public void batchUpdate(final String hql) {
  getHibernateTemplate().execute(new HibernateCallback() {
   public Object doInHibernate(Session session)
     throws HibernateException, SQLException {
    session.createQuery(hql).executeUpdate();
    return null;
   }
  });
 }

 /**
  * 任意执行HQL
  *
  * @return 符合条件的唯对象 or null
  * @author jichun
  */
 public List createHql(final String hql) {
  List list = getHibernateTemplate().executeFind(new HibernateCallback() {
   public Object doInHibernate(Session session)
     throws HibernateException, SQLException {
    List result = session.createQuery(hql).list();
    return result;
   }
  });
  return list;

 }

 /**
  * 字段like后HQL语句
  * @param buffer
  * @param list
  * @param map
  */
 public List  likeHql(StringBuffer buffer, List list, Map map) {
  if (ParamValidate.isEmpty(list))
   list = new ArrayList();
  // buffer
  String group = null;
  String order=null;
  if (buffer.lastIndexOf("group") != -1) {
   group = buffer.substring(buffer.lastIndexOf("group"), buffer
     .length());
   buffer = buffer.replace(buffer.lastIndexOf("group"), buffer
     .length(), "");
  }

  if (buffer.lastIndexOf("order") != -1) {
   group = buffer.substring(buffer.lastIndexOf("order"), buffer
     .length());
   buffer = buffer.replace(buffer.lastIndexOf("order"), buffer
     .length(), "");
  }
  
  String searchField = (String) map.get(PageConstant.SEARCH_FIELD);
  String searchValue = (String) map.get(PageConstant.SEARCH_VALUE);
  if (ParamValidate.isNotEmpty(searchField)) {
   buffer.append(" and " + searchField + " like " + " (  ? )  ");
   list.add(ParamValidate.isEmpty(searchValue) ? "%%": "%" + searchValue
     + "%");
  }
  if (group != null)
   buffer.append(" "+group+" ");
  
  if (order!=null)
   buffer.append(" "+order+" ");

  return list;
 }

 /**
  * 本地分页查询语句 支持列表控件搜索
  * @return
  */
 public List findBySqlPage(Map map, List paramList, StringBuffer hql) {
  likeHql(hql, paramList, map);
  map.put(PageConstant.HQL, hql.toString());
  return findBySQLPage(map, paramList);
 }

 /**
  * 本地查询方法 查找列表总数
  * @param hql
  * @param values
  * @return
  */
 public long getRowSQLCount(StringBuffer hql, List<Object> paramList, Map map) {
  likeHql(hql, paramList, map);
  Query query = createSQLQuery(hql.toString(), paramList);
  long num = ((BigInteger) query.uniqueResult()).longValue();
  if (paramList != null)
   paramList.clear();
  return num;
 }

 /**
  * 本地查询方法 查找列表总数
  * @param hql
  * @param values
  * @return
  */
 public long getRowCount(StringBuffer hql, List<Object> paramList, Map map) {
  paramList=likeHql(hql, paramList, map);
  Query query = createQuery(hql.toString(), paramList);
  long num = (Long) query.uniqueResult();
  if (paramList != null)
   paramList.clear();
  return num;
 }
 
 
 /**
  * 本地分页查询语句 支持列表控件搜索
  * @return
  */
 public List findByPage(Map map, List paramList, StringBuffer hql) {
  paramList=likeHql(hql, paramList, map);
  map.put(PageConstant.HQL, hql.toString());
  return findByPage(map, paramList);
 }

 /**
  * 本地查询方法 查找列表总数
  * @param hql
  * @param values
  * @return
  */
 public long getRowSQLCount(String hql, List<Object> values) {
  Query query = createSQLQuery(hql, values);
  long num = ((BigInteger) query.uniqueResult()).longValue();
  if (values != null)
   values.clear();
  return num;
 }
}

wal812834184
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
hibernate两种初始化方式
liu1277109419的博客
06-03 837
一、编程方式 Java代码： Configuration cfg = new Configuration(); Properties prop = new Properties(); prop.load( TestHibernate.class.getClassLoader().getResourceAsStream("config/jdb
hibernate基础知识
jiqiujia的专栏
01-06 664
软件开发的分层思想： 三层架构：   数据表现层 业务逻辑层 数据持久层 SUN的桌面应用 Swing AWT 普通Java类 JDBC SUN的WEB基本应用 JSP 普通Servlet JDBC SUN的WEB高级应用 JSF SessionBean Persistence WEB国内流行开源 Stru
改进版的hibernate泛型dao(依赖spring)
scott.cgi
12-26 4957
结构看图：HinernateEntityDao和HibernateGenericDao都继承在spring的HibernateDaoSupport一个提供和实体相关的操作,一个提供和实体类无关的操作。然后以组合的方式在BaseDao中使用,这样程序中全部使用IBaseDao接口来操作数据,便于修改和维护.xml配置实用如下:xml version="1.
[转]spring 3.0 应用springmvc 构造RESTful URL 详细讲解(一)
wangqiaowqo的专栏
08-05 95
只有对应的HandlerMapping（为了实现类型级别的注解）和/或HandlerAdapter（为了实现方法级别的注解）出现在dispatcher中时， @RequestMapping才会被处理。 这在DispatcherServlet和DispatcherPortlet中都是缺省的行为。 然而，如果是在定义自己的HandlerMappings或HandlerAdapters， 就需要...
Hibernate的五种数据检索方式
l_feilong的博客
03-02 513
Hibernate检索数据的五种方式： 1.导航对象图检索方式。（根据已经加载的对象，导航到其他对象。） 2.OID检索方式。（按照对象的OID来检索对象。） 3.HQL检索方式。（使用面向对象的HQL查询语言。） 4.QBC检索方式。（使用QBC(Qurey By Criteria) API来检索对象。） 5.本地SQL检索方式。（使用本地数据库的SQL查询语句。） 1、导航对象
Hibernate 中的联合主键解决方案
MZULE CSDN
02-07 947
有时候一张表中会定义多个主键，即联合主键，Hibernate 对联合主键也提供了支持，由于 Annotation 现在用的比 XML 更加流行，则本文以 Annotation 讲解。 既然一张表中定义了联合主键，则在面向对象的思想中，他们都是主键，在 JAVA 中可以专门定义一个类来存放主键，Hibernate 文档说明此主键类必须实现 Serializable 接口，并且要重写 equals() 方法和 hashCode() 方法。定义如下主键类 ApplePk： 1: package
hibernate 通用泛型DAO
gaojiyinhang2的专栏
11-03 581
package org.lzpeng.dao;      import java.io.Serializable;   import java.util.List;   import org.hibernate.Criteria;   import org.hibernate.Query;   import org.hibernate.criterion.Criterion;   i
Hibernate泛型Dao
10-18
在传统的Hibernate使用中，针对每个实体类，我们都需要创建一个对应的Dao（Data Access Object）接口及其实现类，这无疑增加了大量重复的代码。泛型Dao的出现，就是为了解决这个问题，它允许开发者通过泛型来定义一...
基于Struts 2和Hibernate的Blog实现
07-21
而"src"目录则包含源代码，包括Struts 2的配置文件、Action类、实体类、DAO接口及其实现、JSP视图等。 总的来说，这个项目为初学者提供了一个学习Struts 2和Hibernate整合应用的良好实例，同时也展示了如何构建一个...
JPA(hibernate) Dao 和 DaoSupport
04-13
在Spring框架中，`DaoSupport`是一个抽象类，为DAO实现提供了一些基础支持，比如初始化和关闭数据库资源。继承自`DaoSupport`的DAO类可以利用其提供的便利方法，如`getJdbcTemplate()`或`getHibernateTemplate()`，...
IDEA+Spring+Hibernate+Structs2实现简单登录功能
05-26
在本项目中，我们利用IntelliJ IDEA（IDEA）作为集成开发环境，Spring作为核心框架，Hibernate作为持久层框架，Struts2作为表现层框架，来构建一个简单的登录功能。这个组合通常被称为SSH（Spring、Struts2、...
Hibernate基础学习
10-15
【Hibernate基础学习】 在本文中，我们将探讨Hibernate框架的基础知识，包括其原理、优缺点以及在MyEclipse环境中如何配置和使用。Hibernate是一个强大的ORM（对象-关系映射）工具，它简化了Java应用程序与关系...
hibernate高级工具类（含分页）
专注做分享
11-02 1293
最近笔者在研究一套系统（jeeCMS）的源码，看到他对于hibernate的封装，顿时生出一种惊为天人的感觉，特与诸君分享。 这里面用到了两个基础知识，笔者在这里列一下，对于hibernate不熟悉读者可以先看下面两几篇博客： hibernate基本操作：https://www.cnblogs.com/jack1995/p/6952704.html hibernate Criteria查询操作：h...
Hibernate5 Dao层基类
shizezhu的博客
08-02 1311
接口:package cn.xxx.xxxx; import java.io.Serializable; import java.util.Collection; import java.util.List; import java.util.Map; import org.hibernate.Session; import org.hibernate.query.Query; /**  *...
一个好用的hibernate泛型dao
开源华尔兹
04-11 403
以前从springside2.0上搞下来的很好用的,基本实现dao零编码只要配置xml文件就行了。 先看图：   一共4层,com.demonstration.hibernate.basedao是我加的用来进一步解耦hibernate和spring的耦合。 原来的官方解释如下： SpringSide对Hibernate做了三层封装： 第一层：HibernateGenericDao，
Hibernate学习笔记 第六章 HQL查询与缓存
又见炊烟
10-04 647
【Hibernate检索方式概述】 *Hibernate提供了以下几种检索对象的方式   - 导航对象图检索方式：根据已经加载的对象导航到其他对象   - OID检索方式：按照对象的OID来检索对象   - HQL检索方式：使用面向对象的HQL查询语言   - QBC检索方式：使用QBC(Query By Criteria) API来检索对象。这种API封装了基于字符串型式的查询语句，提
SSH框架总结，超详细
weixin_43696483的博客
12-26 6928
2.1 什么是struts从简单性来看，Struts是这三个框架中最简单的一个，它是基于MVC的框架。它通过采用JavaServlet/JSP技术，实现了基于Java EEWeb应用的MVC设计模式的应用框架，是MVC的一个具体实现或着说是MVC的一个具体产品。2.2 Struts的核心构成Struts的核心同样也是MVC的核心，Struts是MVC的一个具体产品。（1）Model。
SSH三大框架的概述
皮卡 皮卡 皮卡丘 ~ 啾
11-25 4731
有时间还是要学习的，“活到老 学到老” 要不然人就废废了，来温习框架知识啦！！！！ 一、ssh为 struts+spring+hibernate的一个集成框架，是目前较流行的一种Web应用程序开源框架。 集成SSH框架的系统从职责上分为四层： 表示层（位于最外层（最上层），最接近用户。用于显示数据和接收用户输入的数据，为用户提供一种交互式操作的界面。） 业务逻辑层（业务规则的制定、业务流程的实现等与业务需求有关的系统设计，对于数据访问层而言，它是调用者；对于表示层而言，它却是被调用者。） 数据持久层 有时候
深入探索Stage #2：属性中的XSS注入技术
最新发布
weixin_43822401的博客
06-04 640
在Web安全的学习旅程中，XSS（跨站脚本）注入是一个不可忽视的话题。"XSS Challenges"闯关游戏的Stage #2专为进阶学习者设计，专注于属性中的XSS注入技术。本文将详细介绍这一阶段的实操过程和关键概念。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值