Public  class ClassA{

　　public static ClassA classA;

　　@Resource
　　private Service service;

　　//原理时在工程启动时加载，在静态方法前加载，这样就可以在静态方法中调用注入的方法啦
    @PostConstruct
    public void init() {
        classA = this;
　　　　　classA.service=service;
    }
}

这个时自定义方法的源码，有注释，不多说啦
 1     /**
 2      * Create an expression for the execution of a database
 3      * function.
 4      * @param name  function name
 5      * @param type  expected result type
 6      * @param args  function arguments
 7      * @return expression
 8      */
 9    <T> Expression<T> function(String name, Class<T> type,
10 Expression<?>... args);

咱说说这个类，也就是
ParameterizedFunctionExpression，是如何实现动态组合排序条件，实现decode

<T> Expression<T> function(String name, Class<T> type,
Expression<?>… args);

//这是function实现实际调用的方法；他调用的就是这个类ParameterizedFunctionExpression的构造方法

@Override
public <T> Expression<T> function(String name, Class<T> returnType, Expression<?>… arguments) {
return new ParameterizedFunctionExpression<T>( this, returnType, name, arguments );
}

//ParameterizedFunctionExpression的构造方法

public ParameterizedFunctionExpression(
CriteriaBuilderImpl criteriaBuilder,
Class<X> javaType,
String functionName,
Expression<?>… argumentExpressions) {
super( criteriaBuilder, javaType, functionName );
this.argumentExpressions = Arrays.asList( argumentExpressions );
this.isStandardJpaFunction = STANDARD_JPA_FUNCTION_NAMES.contains( functionName.toUpperCase(Locale.ROOT) );
}

//实现

Expression<Integer> expression = null;

//存储排序条件

List<Expression<?>> argumentExpressions = new ArrayList<Expression<?>>();

//排序字段

argumentExpressions.add(cb.literal(“grade”);

//排序的顺序
argumentExpressions.add(cb.literal(1));

expression = new ParameterizedFunctionExpression<Integer>((CriteriaBuilderImpl) cb, Integer.class, “decode”,
argumentExpressions);