技术标签： spring boot spring data jpa
上一章简单介绍了一下Spring boot和Spring Data JPA的整合和简单使用. 但是在实际开发过程中, 我们发现Spring Data JPA提供的接口太简单了,这样就导致需要编写大量的重复代码. 实际上Spring Data JPA提供了很多种扩展方式. 下面就介绍其中的一种.在上一章的代码基础上,做一些修改,我们会发现在Spring boot 中使用Spring Data JPA 更容易一些.
由于篇幅的问题,本章分两部分
@Data
@MappedSuperclass
public abstract class TableEntity implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
protected Long id;
/** 创建时间 */
@Temporal(TemporalType.TIMESTAMP)
@Column(nullable = false, updatable = false)
protected Date createTime;
/** 最后更新时间 */
@Temporal(TemporalType.TIMESTAMP)
@Column(insertable = false)
protected Date lastModifyTime;
/** 版本号,用于实现乐观锁 */
@Version
@Column(name = "version", nullable = false)
protected int version;
@PrePersist
@PreUpdate
protected void updateDate(){
if(createTime==null){
createTime = new Date();
}
lastModifyTime = new Date();
}
}这个domain的抽象类描述了四个字段, 分别是ID, 记录创建时间, 最后更新时间, 和实现乐观锁的版本号.这都是ORM中常用的字段, 并且这些字段实现了自动更新.
@NoRepositoryBean
public interface BaseJpaRepository<T extends TableEntity, ID extends Serializable> extends JpaRepository<T, ID> {
}@NoRepositoryBean
@Transactional(readOnly = true)
public class SimpleBaseJpaRepository<T extends TableEntity, ID extends Serializable>
extends SimpleJpaRepository<T, ID> implements
BaseJpaRepository<T, ID> {
}注意: 上面这两个类头上的@NoRepositoryBean注解标明这不是一个Repository的bean, 不需要spring 来自动实现Impl子类
仅仅有上面这个扩展接口和扩展实现是不能完成对Spring Data JPA 扩展的. 我们注意到上一章我们只是写了一个 Repository的接口并继承了JpaRepository, 并没有写实现类. 注入这个接口就可以使用它的方法来. 实际上Spring Data JPA依据继承的JpaRepository, 用工厂自动填补了一个子类的. 那么我们虽然扩展了JpaRepository, 但是没有扩展Spring Data JPA的工厂方法,就还是完成扩展. 接下来我们开始扩展工厂类:
public class BaseJpaRepositoryFactory extends JpaRepositoryFactory {
public BaseJpaRepositoryFactory(EntityManager entityManager) {
super(entityManager);
}
@Override
protected Class<?> getRepositoryBaseClass(RepositoryMetadata metadata) {
return SimpleBaseJpaRepository.class;
}
}注意: 这个类继承了JpaRepositoryFactory, 也就是JpaRepository的工厂类, 并且覆盖了getRepositoryBaseClass的方法,让它返回我们扩展的SimpleBaseJpaRepository.
有了扩展工厂类后,还需要有一个创建JpaRepositoryFactory的Factory, 代码示例如下:
public class BaseJpaRepositoryFactoryBean<R extends JpaRepository<T, ID>, T extends TableEntity, ID extends Serializable>
extends JpaRepositoryFactoryBean<R, T, ID> {
public BaseJpaRepositoryFactoryBean(Class<? extends R> repositoryInterface) {
super(repositoryInterface);
}
protected RepositoryFactorySupport createRepositoryFactory(
EntityManager entityManager) {
return new BaseJpaRepositoryFactory(entityManager);
}
}到这里,对Spring Data JPA的扩展框架已经搭好了, 在给BaseJpaRepository和SimpleBaseJpaRepository填写扩展方法之前,我们需要对上个例子中的RepositoryConfig进行一下修改. 找到RepositoryConfig这个类, 将@EnableJpaRepositories注解中的repositoryFactoryBeanClass修改为我们自己的工厂的工厂类 BaseJpaRepositoryFactoryBean.class 代码如下:
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
basePackages = {"org.learning.repository"},
repositoryFactoryBeanClass = BaseJpaRepositoryFactoryBean.class)
public class RepositoryConfig {
private static final String HIBERNATE_DIALECT = "hibernate.dialect";
private static final String HIBERNATE_SHOW_SQL = "hibernate.show.sql";
private static final String HIBERNATE_HBM2DDL_AUTO = "hibernate.hbm2ddl.auto";
private static final String HIBERNATE_EJB_NAMING_STRATEGY = "hibernate.ejb.naming_strategy";
@Autowired
private DataSource dataSource;
@Value("${spring.jpa.show-sql}")
private String showSql;
@Value("${spring.jpa.generate-ddl}")
private String generateDdl;
@Value("${spring.jpa.hibernate.ddl-auto}")
private String hibernateDdl;
@Value("${spring.jpa.database-platform}")
private String databasePlatform;
@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
factory.setJpaVendorAdapter(vendorAdapter);
factory.setDataSource(dataSource);
factory.setPackagesToScan("org.learning.entity");
Map<String, Object> jpaProperties = new HashMap<>();
jpaProperties.put(HIBERNATE_SHOW_SQL, showSql);
jpaProperties.put(HIBERNATE_DIALECT, databasePlatform);
jpaProperties.put(HIBERNATE_HBM2DDL_AUTO, hibernateDdl);
jpaProperties.put(HIBERNATE_EJB_NAMING_STRATEGY, "org.hibernate.cfg.ImprovedNamingStrategy");
factory.setJpaPropertyMap(jpaProperties);
factory.afterPropertiesSet();
return factory;
}
@Bean
public PlatformTransactionManager transactionManager() {
JpaTransactionManager txManager = new JpaTransactionManager();
txManager.setEntityManagerFactory(entityManagerFactory().getObject());
return txManager;
}
}
@NoRepositoryBean
@Transactional(readOnly = true)
public class SimpleBaseJpaRepository<T extends TableEntity, ID extends Serializable>
extends SimpleJpaRepository<T, ID> implements
BaseJpaRepository<T, ID> {
protected EntityManager entityManager;
private final JpaEntityInformation<T, ?> entityInformation;
protected Class<T> domainClass;
/**
* 父类的构造函数
*
* @param entityInformation
* @param entityManager
*/
public SimpleBaseJpaRepository(
JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager) {
super(entityInformation, entityManager);
this.entityManager = entityManager;
this.entityInformation = entityInformation;
this.domainClass = entityInformation.getJavaType();
}
}在构造函数中需要调用父类的构造函数把EntityManager和JpaEntityInformation初始化了.
Spring Data JPA没有提供类似Hibernate中Criteria的动态查询器,但是往往项目中有很多动态查询.那就封装一个吧. 下面是代码示例:
Criterion接口:
public interface Criterion {
/**
* 操作符
*/
enum Operator {
EQ, NE, LIKE, GT, LT, GTE, LTE, AND, OR, ISNULL, ISNOTNULL, LEFTLIKE, RIGHTLIKE, BETWEEN, IN
}
Predicate toPredicate(Root<?> root, CriteriaQuery<?> query, CriteriaBuilder builder);
}Criteria查询器, 继承Specification:
public class Criteria<T> implements Specification<T> {
private List<Criterion> criterions = new ArrayList<Criterion>();
public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
if (!criterions.isEmpty()) {
List<Predicate> predicates = new ArrayList<Predicate>();
for(Criterion c : criterions){
predicates.add(c.toPredicate(root, query, builder));
}
// 将所有条件用 and 联合起来
if (predicates.size() > 0) {
return builder.and(predicates.toArray(new Predicate[predicates.size()]));
}
}
return builder.conjunction();
}
/**
* 增加简单条件表达式
* @param criterion
*/
public void add(Criterion criterion){
if(criterion!=null){
criterions.add(criterion);
}
}
private boolean isField(Field[] fields, String queryKey) {
if (fields == null || fields.length == 0) {
return false;
}
for (Field field : fields) {
if (field.getName().equals(queryKey)) {
return true;
}
}
return false;
}
}再建几个表达式类
public class SimpleExpression implements Criterion {
private String fieldName; //属性名
private Object value; //对应值
private Object[] values; //对应值
private Operator operator; //计算符
protected SimpleExpression(String fieldName, Object value, Operator operator) {
this.fieldName = fieldName;
this.value = value;
this.operator = operator;
}
protected SimpleExpression(String fieldName, Operator operator) {
this.fieldName = fieldName;
this.operator = operator;
}
protected SimpleExpression(String fieldName, Operator operator, Object... values) {
this.fieldName = fieldName;
this.values = values;
this.operator = operator;
}
public String getFieldName() {
return fieldName;
}
public Object getValue() {
return value;
}
public Operator getOperator() {
return operator;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public Predicate toPredicate(Root<?> root, CriteriaQuery<?> query,
CriteriaBuilder builder) {
Path expression ;
if(fieldName.contains(".")){
String[] names = StringUtils.split(fieldName, ".");
expression = root.get(names[0]);
for (int i = 1; i < names.length; i++) {
expression = expression.get(names[i]);
}
}else{
expression = root.get(fieldName);
}
switch (operator) {
case EQ:
return builder.equal(expression, value);
case NE:
return builder.notEqual(expression, value);
case LIKE:
return builder.like((Expression<String>) expression, "%" + value + "%");
case LEFTLIKE:
return builder.like((Expression<String>) expression, "%" + value);
case RIGHTLIKE:
return builder.like((Expression<String>) expression, value + "%");
case LT:
return builder.lessThan(expression, (Comparable) value);
case GT:
return builder.greaterThan(expression, (Comparable) value);
case LTE:
return builder.lessThanOrEqualTo(expression, (Comparable) value);
case GTE:
return builder.greaterThanOrEqualTo(expression, (Comparable) value);
case ISNULL:
return builder.isNull(expression);
case ISNOTNULL:
return builder.isNotNull(expression);
case IN:
return ((CriteriaBuilderImpl)builder).in(expression, values);
default:
return null;
}
}
}public class LogicalExpression implements Criterion {
private Criterion[] criterion; // 逻辑表达式中包含的表达式
private Operator operator; //计算符
LogicalExpression(Criterion[] criterions, Operator operator) {
this.criterion = criterions;
this.operator = operator;
}
@Override
public Predicate toPredicate(Root<?> root, CriteriaQuery<?> query,
CriteriaBuilder builder) {
List<Predicate> predicates = new ArrayList<Predicate>();
for (Criterion aCriterion : this.criterion) {
predicates.add(aCriterion.toPredicate(root, query, builder));
}
switch (operator) {
case OR:
return builder.or(predicates.toArray(new Predicate[predicates.size()]));
default:
return builder.and(predicates.toArray(new Predicate[predicates.size()]));
}
}
}public class BetweenExpression implements Criterion {
private final String fieldName;
private Object lo;
private Object hi;
BetweenExpression(String fieldName, Object lo, Object hi) {
this.fieldName = fieldName;
this.lo = lo;
this.hi = hi;
}
@Override
public Predicate toPredicate(Root<?> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
Path expression ;
if(fieldName.contains(".")){
String[] names = StringUtils.split(fieldName, ".");
expression = root.get(names[0]);
for (int i = 1; i < names.length; i++) {
expression = expression.get(names[i]);
}
}else{
expression = root.get(fieldName);
}
if (lo instanceof Date && hi instanceof Date) {
return builder.between(expression, (Date)lo, (Date)hi);
} else if (lo instanceof String && hi instanceof String) {
return builder.between(expression, (String)lo, (String)hi);
} else if (lo instanceof Integer && hi instanceof Integer) {
return builder.between(expression, (Integer)lo, (Integer)hi);
} else if (lo instanceof Double && hi instanceof Double) {
return builder.between(expression, (Double)lo, (Double)hi);
} else if (lo instanceof BigDecimal && hi instanceof BigDecimal) {
return builder.between(expression, (BigDecimal)lo, (BigDecimal)hi);
} else {
return null;
}
}
}public class ColumnExpression implements Criterion {
private final String fieldNameA;
private final String fieldNameB;
private Operator operator; //计算符
ColumnExpression(String fieldNameA, String fieldNameB, Operator operator) {
this.fieldNameA = fieldNameA;
this.fieldNameB = fieldNameB;
this.operator = operator;
}
@Override
public Predicate toPredicate(Root<?> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
Path expressionA ;
if(fieldNameA.contains(".")){
String[] names = StringUtils.split(fieldNameA, ".");
expressionA = root.get(names[0]);
for (int i = 1; i < names.length; i++) {
expressionA = expressionA.get(names[i]);
}
}else{
expressionA = root.get(fieldNameA);
}
Path expressionB ;
if(fieldNameB.contains(".")){
String[] names = StringUtils.split(fieldNameB, ".");
expressionB = root.get(names[0]);
for (int i = 1; i < names.length; i++) {
expressionB = expressionB.get(names[i]);
}
}else{
expressionB = root.get(fieldNameB);
}
switch (operator) {
case EQ:
return builder.equal(expressionA, expressionB);
case NE:
return builder.notEqual(expressionA, expressionB);
default:
return null;
}
}
}最后是条件比较器Restrictions:
public class Restrictions {
/**
* 等于
* @param fieldName
* @param value
* @return
*/
public static SimpleExpression eq(String fieldName, Object value) {
if(value == null) {
return null;
}
return new SimpleExpression (fieldName, value, Criterion.Operator.EQ);
}
/**
* 不等于
* @param fieldName
* @param value
* @return
*/
public static SimpleExpression ne(String fieldName, Object value) {
if(value == null) {
return null;
}
return new SimpleExpression (fieldName, value, Criterion.Operator.NE);
}
/**
* 模糊匹配
* @param fieldName
* @param value
* @return
*/
public static SimpleExpression like(String fieldName, String value) {
if(value == null) {
return null;
}
return new SimpleExpression (fieldName, value, Criterion.Operator.LIKE);
}
/**
* 模糊匹配
* @param fieldName
* @param value
* @return
*/
public static SimpleExpression leftLike(String fieldName, String value) {
if(value == null) {
return null;
}
return new SimpleExpression (fieldName, value, Criterion.Operator.LEFTLIKE);
}
/**
* 模糊匹配
* @param fieldName
* @param value
* @return
*/
public static SimpleExpression rightLike(String fieldName, String value) {
if(value == null) {
return null;
}
return new SimpleExpression (fieldName, value, Criterion.Operator.RIGHTLIKE);
}
/**
* 大于
* @param fieldName
* @param value
* @return
*/
public static SimpleExpression gt(String fieldName, Object value) {
if(value == null) {
return null;
}
return new SimpleExpression (fieldName, value, Criterion.Operator.GT);
}
/**
* 小于
* @param fieldName
* @param value
* @return
*/
public static SimpleExpression lt(String fieldName, Object value) {
if(value == null) {
return null;
}
return new SimpleExpression (fieldName, value, Criterion.Operator.LT);
}
/**
* 大于等于
* @param fieldName
* @param value
* @return
*/
public static SimpleExpression gte(String fieldName, Object value) {
if(value == null) {
return null;
}
return new SimpleExpression (fieldName, value, Criterion.Operator.GTE);
}
/**
* 小于等于
* @param fieldName
* @param value
* @return
*/
public static SimpleExpression lte(String fieldName, Object value) {
if(value == null) {
return null;
}
return new SimpleExpression (fieldName, value, Criterion.Operator.LTE);
}
/**
* 并且
* @param criterions
* @return
*/
public static LogicalExpression and(Criterion... criterions){
return new LogicalExpression(criterions, Criterion.Operator.AND);
}
/**
* 或者
* @param criterions
* @return
*/
public static LogicalExpression or(Criterion... criterions){
return new LogicalExpression(criterions, Criterion.Operator.OR);
}
/**
* 包含于
* @param fieldName
* @param value
* @return
*/
@SuppressWarnings("rawtypes")
public static SimpleExpression in(String fieldName, Collection value) {
return new SimpleExpression(fieldName, Criterion.Operator.IN, value.toArray());
}
/**
* 不包含于
* @param fieldName
* @param value
* @return
*/
@SuppressWarnings("rawtypes")
public static LogicalExpression notIn(String fieldName, Collection value) {
if((value==null||value.isEmpty())){
return null;
}
SimpleExpression[] ses = new SimpleExpression[value.size()];
int i=0;
for(Object obj : value){
ses[i]=new SimpleExpression(fieldName,obj, Criterion.Operator.NE);
i++;
}
return new LogicalExpression(ses, Criterion.Operator.AND);
}
/**
* 列为空
* @param fieldName
* @return
*/
public static LogicalExpression isNull(String fieldName) {
SimpleExpression[] ses = new SimpleExpression[1];
ses[0] = new SimpleExpression(fieldName, Criterion.Operator.ISNULL);
return new LogicalExpression(ses, Criterion.Operator.ISNULL);
}
/**
* 列不为空
* @param fieldName
* @return
*/
public static LogicalExpression isNotNull(String fieldName) {
SimpleExpression[] ses = new SimpleExpression[1];
ses[0] = new SimpleExpression(fieldName, Criterion.Operator.ISNOTNULL);
return new LogicalExpression(ses, Criterion.Operator.ISNOTNULL);
}
/**
* 时间范围
* @param fieldName
* @return
*/
public static LogicalExpression between(String fieldName, Object startDate, Object endDate) {
BetweenExpression[] bes = new BetweenExpression[1];
bes[0] = new BetweenExpression(fieldName, startDate, endDate);
return new LogicalExpression(bes, Criterion.Operator.BETWEEN);
}
/**
* 等于
* @param fieldNameA
* @param fieldNameB
* @return
*/
public static ColumnExpression eqCol(String fieldNameA, String fieldNameB) {
if(StringUtil.isBlank(fieldNameA) || StringUtil.isBlank(fieldNameB)) {
return null;
}
return new ColumnExpression(fieldNameA, fieldNameB, Criterion.Operator.EQ);
}
/**
* bu等于
* @param fieldNameA
* @param fieldNameB
* @return
*/
public static ColumnExpression neCol(String fieldNameA, String fieldNameB) {
if(StringUtil.isBlank(fieldNameA) || StringUtil.isBlank(fieldNameB)) {
return null;
}
return new ColumnExpression(fieldNameA, fieldNameB, Criterion.Operator.NE);
}
/**
* 时间范围
* @param fieldName
* @return
*/
public static LogicalExpression eqDate(String fieldName, Object date) {
BetweenExpression[] bes = new BetweenExpression[1];
Date startDate;
Date endDate;
try {
if(date instanceof String){
startDate = stringToDateTime(date.toString() + " 00:00:00");
endDate = stringToDateTime(date.toString() + " 23:59:59");
}else if(date instanceof Date){
Calendar calendar = Calendar.getInstance();
calendar.setTime((Date)date);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND,0);
startDate = calendar.getTime();
calendar.set(Calendar.HOUR_OF_DAY,23);
calendar.set(Calendar.MINUTE,59);
calendar.set(Calendar.SECOND,59);
endDate = calendar.getTime();
}else{
return null;
}
}catch (Exception ignored){
return null;
}
bes[0] = new BetweenExpression(fieldName, startDate, endDate);
return new LogicalExpression(bes, Criterion.Operator.BETWEEN);
}
private final static String DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
private static Date stringToDateTime(String dateString) {
if (dateString == null) {
return null;
}
try {
DateFormat df = new SimpleDateFormat(DATETIME_PATTERN);
df.setLenient(false);
return df.parse(dateString);
} catch (ParseException e) {
return null;
}
}
}本章结束
本章介绍了jpa封装的部分代码, 下一章接着展示后面的代码
文章浏览阅读5.7k次。Csdn实训总结 CSDN Java班 乔晓松 111307156 为期7天的暑假实训结束了，我感觉我的收获很大。实训让我了解到了以前不曾了解的信息，使我重新确立了我的目标，不像以前那样迷茫。实训更加的让我体会到了团队精神，我身处其中，我很欣慰、很开心，享受团队的力量。实训前5天，是企业老师给我们授课，讲的是android的开发，都是一些基本知识，让我们有个初步的了解，暑假有时_java实训报告拨号系统
文章浏览阅读2.8k次，点赞3次，收藏8次。Python结合selenium,360浏览器实现自动测试常见操作，textbox,select,datepicker,input赋值，自动登录，单击菜单_driver = webdriver.chrome(service=service, options=options)
文章浏览阅读4k次，点赞3次，收藏7次。一、 编写Dockerfie如下，Dockerfile 与 jdk 的gz包在同一级目录FromcentosMAINTAINERgnauhsilRUNmkdir/usr/local/jdk8ADDjdk-8u191-linux-x64.tar.gz/usr/local/jdk8ENVJAVA_HOME/usr/local/jdk8/jdk1.8.0_191ENVJRE_HOME/usr/local/jdk8/jdk1.8.0_191/jreENVPATH..._docker制作jdk镜像
文章浏览阅读2.2k次。上节中只是提到了如何找到迷宫的通路，但是很显然有些迷宫不止一条通路，所以怎样才能求得迷宫最短路径呢？要找到最短路径，那必然需要知道所有的路径，才能找出最短路径。所以最重要的还是利用栈和回溯法，同时和递归结合起来。思路：首先从入口点开始，查找下一个结点的时候要与当前结点进行比较，因为所有路过的结点都是被标记的，表示的是从入口点到当前点所走的长度，而且都是递增。所以有可能被比较的对_迷宫寻路求解最短路径
文章浏览阅读2.7k次，点赞3次，收藏14次。@TOC1、面试题模块汇总面试题包括以下十九个模块：Java 基础、容器、多线程、反射、对象拷贝、Java Web 模块、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、Mybatis、RabbitMQ、Kafka、Zookeeper、MySql、Redis、JVM 。如下图所示：可能对于初学者不需要后面的框架和 ...
文章浏览阅读90次。分布式RPC框架Apache Dubbo1. 软件架构的演进过程软件架构的发展经历了由单体架构、垂直架构、SOA架构到微服务架构的演进过程，下面我们分别了解一下这几个架构。1.1 单体架构架构说明： 全部功能集中在一个项目内（All in one）。架构优点： 架构简单，前期开发成本低、开发周期短，适合小型项目。架构缺点： 全部功能集成在一个工程中，对于大型项目不易开发、扩展和维护。 技术栈受限，只能使用一种语言开发。 _apach dubbo讲义
文章浏览阅读2k次。RISC-V ISA 是一种可扩展的、模块化的指令集，它被设计为适用于各种各样的硬件和软件场景。RISC-V 的成功不仅在于其优秀的设计，更在于它的开放性和社区。通过开放的标准和活跃的社区，RISC-V 能够吸引全球各地的人才和资源，使得其在硬件和软件领域的应用越来越广泛。高效性：由于 RISC-V 指令集的简洁性和灵活性，它可以轻松地进行优化，以实现高效的处理能力和低功耗的设计。可扩展性：RISC-V 的指令集具有可扩展性，可以通过添加新的扩展指令集，从而实现更多的功能和性能提升。_risc-v开放架构设计之道
文章浏览阅读2.6k次，点赞3次，收藏15次。EndNoteX9 使用笔记 文章目录 EndNoteX9 使用笔记1、endnote导入文献的方式1.1. 直接检索1.2.网站输出1.3. PDF导入1.4. 手动导入1.5. 软件之间数据的交换 2、endnote的详细功能2.1. 实现功能2.2. 管理功能 3、编辑参考文献格式3.1. 如何插入参考文献3.2. 如何编辑参考文献格式3.3. 如何手动修改参考文献格式 4、利用endnot..._endnote 9笔记
文章浏览阅读3.4k次。以前碰到过的打包的java程序都可以用winrar解压得到jar文件从而进行进一步的反编译，然而今天碰到一个用exe4j打包的程序，无法直接用winrar解压，上网查资料未果。后来想到这个程序的原理是将jar全部解压然后调用java运行库执行，于是到temp文件夹中搜索*.jar，果然找到了目标程序。很简单的原理，供后来者参考。_exe4jlib.jar
文章浏览阅读538次。背景随着搜索技术的持续发展，我们已经逐渐意识到监督学习算法在搜索场景的局限性：搜索场景中，只有被当前投放策略排到前面的商品，才会获得曝光机会，从而形成监督学习的正负样本，而曝光出来的商品，只占总的召回商品中的很小一部分，训练样本是高度受当前模型的bias影响的。监督学习的损失函数，和业务关注的指标之间，存在着不一致性用户的搜索、点击、购买行为，..._电商 算法 reward
文章浏览阅读3k次，点赞6次，收藏14次。语义搜索是一种先进的信息检索技术，旨在通过理解搜索查询和搜索内容的上下文和含义来提高搜索结果的准确性和相关性。总体而言，NLP 语义搜索提供了更复杂和上下文感知的搜索功能，使其在各种应用中都很有价值，包括网络搜索引擎、企业搜索、电子商务、聊天机器人和虚拟助理，在这些应用中，理解和满足用户的意图至关重要。与传统方法相比，BERT 的上下文理解可以显着提高搜索结果的质量。自然语言处理（NLP）上下文中的语义搜索是指应用NLP技术通过理解搜索查询和正在搜索的内容的含义和上下文来增强搜索结果的准确性和相关性。_语义搜索
文章浏览阅读650次。一.背景4月，随着moonbirds 短时间破纪录交易额引爆市场，bayc土地即将发行带领yuga club家族蓝筹猛涨，村上隆花和NBA在科学家们几百万份邮件和漏洞攻击中无法抵挡，pass通证类项目也在细分赛道中逐渐真香， NFT市场整体迎来了一波小行情。但蓝筹市场的火热，也加剧着NFT市场本就严重的马太效应，就如那句老话，金钱往往流向不缺钱的人，苦难往往流向能吃苦的人，对应到NFT市场中，优质项目的入场券流向了不缺钱的鲸鱼和顶尖科学家口袋，破发归零土狗项目流向了没钱希望暴富但被割的韭菜._nft底层逻辑是