@SuppressWarnings("unchecked")
@Override
public List<T> findBy(List<String> propertyNames, List<Object> values) {
Assert.notEmpty(propertyNames);
Assert.notEmpty(values);
Assert.state(propertyNames.size() == values.size());
List<Criterion> criterions = new ArrayList<Criterion>(5);
for (int i = 0; i < propertyNames.size(); i++) {
Criterion criterion = Restrictions.eq(propertyNames.get(i), values.get(i));
criterions.add(criterion);
}
return createCriteria(criterions).list();
}
public ProductTag[] updateTagName(Long[] ids, String[] tagNames) {
Assert.notEmpty(ids);
Assert.notEmpty(tagNames);
if (ids.length != tagNames.length) {
throw new IllegalArgumentException("ids length not equals tagNames length");
}
ProductTag[] tags = new ProductTag[ids.length];
ProductTag tag;
for (int i = 0, len = ids.length; i < len; i++) {
tag = findById(ids[i]);
tag.setName(tagNames[i]);
tags[i] = tag;
}
return tags;
}
@Test
public void testGetMenuList() {
Map<Object, Object> condition = new HashMap<Object, Object>();
condition.put("paging", new Paging());
condition.put("user", new User());
Assert.notEmpty(menuDao.getMenuList(condition), "查询数据没有值");
}
private <T> MultiGetResponse getMultiResponse(Query searchQuery, Class<T> clazz) {
String indexName =
isNotEmpty(searchQuery.getIndices())
? searchQuery.getIndices().get(0)
: getPersistentEntityFor(clazz).getIndexName();
String type =
isNotEmpty(searchQuery.getTypes())
? searchQuery.getTypes().get(0)
: getPersistentEntityFor(clazz).getIndexType();
Assert.notNull(indexName, "No index defined for Query");
Assert.notNull(type, "No type define for Query");
Assert.notEmpty(searchQuery.getIds(), "No Id define for Query");
MultiGetRequestBuilder builder = client.prepareMultiGet();
for (String id : searchQuery.getIds()) {
MultiGetRequest.Item item = new MultiGetRequest.Item(indexName, type, id);
if (searchQuery.getRoute() != null) {
item = item.routing(searchQuery.getRoute());
}
if (searchQuery.getFields() != null && !searchQuery.getFields().isEmpty()) {
item = item.fields(toArray(searchQuery.getFields()));
}
builder.add(item);
}
return builder.execute().actionGet();
}
/**
* 创建Zipper对象
*
* @param out 输出流
* @param filter 文件过滤，不过滤可以为null。
* @param srcFilename 源文件名。可以有多个源文件，如果源文件是目录，那么所有子目录都将被包含。
*/
protected Zipper(OutputStream out, List<FileEntry> fileEntrys, String encoding) {
Assert.notEmpty(fileEntrys);
long begin = System.currentTimeMillis();
log.debug("开始制作压缩包");
try {
try {
zipOut = new ZipOutputStream(out);
if (!StringUtils.isBlank(encoding)) {
log.debug("using encoding: {}", encoding);
zipOut.setEncoding(encoding);
} else {
log.debug("using default encoding");
}
for (FileEntry fe : fileEntrys) {
zip(fe.getFile(), fe.getFilter(), fe.getZipEntry(), fe.getPrefix());
}
} finally {
zipOut.close();
}
} catch (IOException e) {
throw new RuntimeException("制作压缩包时，出现IO异常！", e);
}
long end = System.currentTimeMillis();
log.info("制作压缩包成功。耗时：{}ms。", end - begin);
}
/**
* Initiate a copy operation using a command-line style (arguments are specified as {@link
* String}s).
*
* @param arguments the copy arguments
*/
public void copy(String... arguments) {
Assert.notEmpty(arguments, "invalid number of arguments");
// sanitize the arguments
final List<String> parsedArguments = new ArrayList<String>();
for (String arg : arguments) {
parsedArguments.addAll(Arrays.asList(StringUtils.tokenizeToStringArray(arg, " ")));
}
try {
if (StringUtils.hasText(user)) {
UserGroupInformation ugi =
UserGroupInformation.createProxyUser(user, UserGroupInformation.getLoginUser());
ugi.doAs(
new PrivilegedExceptionAction<Void>() {
@Override
public Void run() throws Exception {
invokeCopy(
configuration, parsedArguments.toArray(new String[parsedArguments.size()]));
return null;
}
});
} else {
invokeCopy(configuration, parsedArguments.toArray(new String[parsedArguments.size()]));
}
} catch (Exception ex) {
throw new IllegalStateException("Cannot run distCp impersonated as '" + user + "'", ex);
}
}
/**
* Create a custom CustomAnnotationTransactionAttributeSource.
*
* @param annotationParsers the TransactionAnnotationParsers to use
*/
public CustomAnnotationTransactionAttributeSource(
Set<TransactionAnnotationParser> annotationParsers) {
this.publicMethodsOnly = true;
Assert.notEmpty(
annotationParsers, "At least one TransactionAnnotationParser needs to be specified");
this.annotationParsers = annotationParsers;
}
/**
* Perform a scan within the specified base packages, returning the registered bean definitions.
*
* <p>This method does <i>not</i> register an annotation config processor but rather leaves this
* up to the caller.
*
* @param basePackages the packages to check for annotated classes
* @return set of beans registered if any for tooling registration purposes (never {@code null})
*/
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
mylog.debug("遍历basePackages，获取包路径下面的.class所有类");
for (String basePackage : basePackages) {
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
mylog.debug("获取到有注解的bean集合并遍历，每个bean设置scope");
for (BeanDefinition candidate : candidates) {
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
AnnotationConfigUtils.processCommonDefinitionAnnotations(
(AnnotatedBeanDefinition) candidate);
}
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(
scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
mylog.debug("登记AnnotatedBeanDefinition类型的bean");
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
/** Initialize the selector chain. Removes any existing selectors. */
public void setSelectors(List<MessageSelector> selectors) {
Assert.notEmpty(selectors, "selectors must not be empty");
synchronized (this.selectors) {
this.selectors.clear();
this.selectors.addAll(selectors);
}
}
@Override
public void returns(Order order, Returns returns, Admin operator) {
Assert.notNull(order);
Assert.notNull(returns);
Assert.notEmpty(returns.getReturnsItems());
orderDao.lock(order, LockModeType.PESSIMISTIC_WRITE);
returns.setOrder(order);
returnsDao.persist(returns);
for (ReturnsItem returnsItem : returns.getReturnsItems()) {
OrderItem orderItem = order.getOrderItem(returnsItem.getSn());
if (orderItem != null) {
orderItemDao.lock(orderItem, LockModeType.PESSIMISTIC_WRITE);
orderItem.setReturnQuantity(orderItem.getReturnQuantity() + returnsItem.getQuantity());
}
}
if (order.getReturnQuantity() >= order.getShippedQuantity()) {
order.setShippingStatus(ShippingStatus.returned);
} else if (order.getReturnQuantity() > 0) {
order.setShippingStatus(ShippingStatus.partialReturns);
}
order.setExpire(null);
orderDao.merge(order);
OrderLog orderLog = new OrderLog();
orderLog.setType(Type.returns);
orderLog.setOperator(operator != null ? operator.getUsername() : null);
orderLog.setOrder(order);
orderLogDao.persist(orderLog);
}
public JythonScriptFactory(String scriptSourceLocator, Class[] scriptInterfaces) {
Assert.hasText(scriptSourceLocator);
Assert.notEmpty(scriptInterfaces);
this.scriptSourceLocator = scriptSourceLocator;
this.scriptInterfaces = scriptInterfaces;
this.arguments = null;
}
@Override
public PrivateCoachInfoDto getCoachProfile(String coachId) {
StringBuffer sql = new StringBuffer();
sql.append("SELECT ")
.append("s.portrait_photo as portraitPhoto, ")
.append("CONCAT (s.given_name, ' ' ,s.surname) AS nickname, ")
.append(
"(SELECT position_name FROM position_title WHERE position_code = m.position_title_code) as positionTitle, ")
.append("(CASE (s.gender) when 'F' then 'F' when 'M' then 'M' else 'N' end) as sex, ")
.append("s.date_of_birth as dateOfBirth, ")
.append(
"(SELECT code_display FROM sys_code where category = 'nationality' and code_value = s.nationality) as nationality, ")
.append("c.personal_info as qualification, ")
.append("c.speciality ")
.append("FROM ")
.append("user_master u ")
.append("LEFT JOIN ")
.append("staff_profile s ON (s.user_id = u.user_id) ")
.append("LEFT JOIN ")
.append("staff_master m ON (u.user_id = m.user_id) ")
.append("LEFT JOIN ")
.append("staff_coach_info c ON (c.user_id = u.user_id) ")
.append("WHERE ")
.append("u.user_id = '")
.append(coachId)
.append("'");
List<PrivateCoachInfoDto> dtoList =
this.getDtoBySql(sql.toString(), null, PrivateCoachInfoDto.class);
Assert.notEmpty(dtoList, "No such coach");
Assert.isTrue(dtoList.size() == 1, "More than one coach have the same coach id");
return dtoList.get(0);
}
/**
* Genera un pago para el grupo de cargos indicado
*
* @param c
* @param cargos
* @return
*/
public PagoM crearPago(final Cliente c, final List<NotaDeCredito> cargos) {
Assert.notEmpty(cargos, "La collecion de cargos debe tener elementos");
final PagoM pago = new PagoM();
pago.setCliente(c);
pago.setClave(c.getClave());
pago.setTipoDeDocumento("M");
CollectionUtils.forAllDo(
cargos,
new Closure() {
public void execute(Object input) {
NotaDeCredito cargo = (NotaDeCredito) input;
Pago p = new Pago();
p.setCliente(pago.getCliente());
p.setClave(pago.getClave());
p.setPagoM(pago);
p.setNota(cargo);
pago.getPagos().add(p);
p.setOrigen(cargo.getOrigen());
p.setTipoDocto(cargo.getTipo());
p.setNumero(cargo.getNumero());
p.setSucursal(1);
}
});
return pago;
}
/**
* Set the names of the beans that should automatically get wrapped with proxies. A name can
* specify a prefix to match by ending with "*", e.g. "myBean,tx*" will match the bean named
* "myBean" and all beans whose name start with "tx".
*
* <p><b>NOTE:</b> In case of a FactoryBean, only the objects created by the FactoryBean will get
* proxied. This default behavior applies as of Spring 2.0. If you intend to proxy a FactoryBean
* instance itself (a rare use case, but Spring 1.2's default behavior), specify the bean name of
* the FactoryBean including the factory-bean prefix "&": e.g. "&myFactoryBean".
*
* @see org.springframework.beans.factory.FactoryBean
* @see org.springframework.beans.factory.BeanFactory#FACTORY_BEAN_PREFIX
*/
public void setBeanNames(String... beanNames) {
Assert.notEmpty(beanNames, "'beanNames' must not be empty");
this.beanNames = new ArrayList<String>(beanNames.length);
for (String mappedName : beanNames) {
this.beanNames.add(StringUtils.trimWhitespace(mappedName));
}
}
public AbstractStompEndpointRegistration(
String[] paths, WebSocketHandler webSocketHandler, TaskScheduler sockJsTaskScheduler) {
Assert.notEmpty(paths, "No paths specified");
this.paths = paths;
this.wsHandler = webSocketHandler;
this.sockJsTaskScheduler = sockJsTaskScheduler;
}
/**
* Set the regular expressions defining methods to match for exclusion. Matching will be the union
* of all these; if any match, the pointcut matches.
*/
public void setExcludedPatterns(String[] excludedPatterns) {
Assert.notEmpty(excludedPatterns, "'excludedPatterns' must not be empty");
this.excludedPatterns = new String[excludedPatterns.length];
for (int i = 0; i < excludedPatterns.length; i++) {
this.excludedPatterns[i] = StringUtils.trimWhitespace(excludedPatterns[i]);
}
initExcludedPatternRepresentation(this.excludedPatterns);
}
/**
* Provide the map of {@link HeaderValueMessageProcessor} to evaluate when enriching the target
* MessageHeaders. The keys should simply be header names, and the values should be Expressions
* that will evaluate against the reply Message as the root object.
*
* @param headerExpressions The header expressions.
*/
public void setHeaderExpressions(Map<String, HeaderValueMessageProcessor<?>> headerExpressions) {
Assert.notEmpty(headerExpressions, "headerExpressions must not be empty");
Assert.noNullElements(
headerExpressions.keySet().toArray(), "headerExpressions keys must not be empty");
Assert.noNullElements(
headerExpressions.values().toArray(), "headerExpressions values must not be empty");
this.headerExpressions = new HashMap<String, HeaderValueMessageProcessor<?>>(headerExpressions);
}
/**
* Create a custom AnnotationCacheOperationSource.
*
* @param annotationParsers the CacheAnnotationParser to use
*/
public AnnotationCacheOperationSource(CacheAnnotationParser... annotationParsers) {
this.publicMethodsOnly = true;
Assert.notEmpty(annotationParsers, "At least one CacheAnnotationParser needs to be specified");
Set<CacheAnnotationParser> parsers =
new LinkedHashSet<CacheAnnotationParser>(annotationParsers.length);
Collections.addAll(parsers, annotationParsers);
this.annotationParsers = parsers;
}
/**
* Set the regular expressions defining methods to match. Matching will be the union of all these;
* if any match, the pointcut matches.
*/
public void setPatterns(String[] patterns) {
Assert.notEmpty(patterns, "'patterns' must not be empty");
this.patterns = new String[patterns.length];
for (int i = 0; i < patterns.length; i++) {
this.patterns[i] = StringUtils.trimWhitespace(patterns[i]);
}
initPatternRepresentation(this.patterns);
}
@SuppressWarnings("unchecked")
public void delete(PK[] ids) {
Assert.notEmpty(ids, "ids must not be empty");
for (PK id : ids) {
T entity = (T) getSession().load(entityClass, id);
getSession().delete(entity);
}
}
@JsonIgnore
public List<Item> getOnLoanItemsFilterByItemCategoriesAndSmds(
List<ItemCategory> itemCategoryList, List<SMD> smdList) {
logger.debug(
"Entering getOnLoanItemsFilterByItemCategoriesAndSmds(itemCategoryList={}, smdList={})",
new Object[] {itemCategoryList, smdList});
Assert.notEmpty(itemCategoryList);
Assert.notEmpty(smdList);
List<Item> onLoanItems =
itemRepo.findByPatronAndItemStatusAndItemCategoryAndSmd(
this, getCirculatedItemStatusList(), itemCategoryList, smdList, null);
logger.debug(
"Leaving getOnLoanItemsFilterByItemCategoriesAndSmds(). onLoanItems={}", onLoanItems);
return onLoanItems;
}
@Override
public DefaultDataBuffer write(ByteBuffer... byteBuffers) {
Assert.notEmpty(byteBuffers, "'byteBuffers' must not be empty");
int extraCapacity = Arrays.stream(byteBuffers).mapToInt(ByteBuffer::remaining).sum();
ensureExtraCapacity(extraCapacity);
Arrays.stream(byteBuffers)
.forEach(byteBuffer -> writeInternal(buffer -> buffer.put(byteBuffer)));
return this;
}
/**
* Create an instance with the given ContentNegotiationStrategy instances.
*
* <p>Each instance is checked to see if it is also an implementation of
* MediaTypeFileExtensionResolver, and if so it is registered as such.
*
* @param strategies one more more ContentNegotiationStrategy instances
*/
public ContentNegotiationManager(ContentNegotiationStrategy... strategies) {
Assert.notEmpty(strategies, "At least one ContentNegotiationStrategy is expected");
this.contentNegotiationStrategies.addAll(Arrays.asList(strategies));
for (ContentNegotiationStrategy strategy : this.contentNegotiationStrategies) {
if (strategy instanceof MediaTypeFileExtensionResolver) {
this.fileExtensionResolvers.add((MediaTypeFileExtensionResolver) strategy);
}
}
}
/**
* @throws Exception
* @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
*/
public void afterPropertiesSet() throws Exception {
Assert.notEmpty(
getGroupList(),
"The property groupList in class "
+ this.getClass().getSimpleName()
+ " must not be null and not empty.");
this.setAsText(getGroupList());
}
@SuppressWarnings("unchecked")
HttpMessageConverterExtractor(
Type responseType, List<HttpMessageConverter<?>> messageConverters, Log logger) {
Assert.notNull(responseType, "'responseType' must not be null");
Assert.notEmpty(messageConverters, "'messageConverters' must not be empty");
this.responseType = responseType;
this.responseClass = (responseType instanceof Class) ? (Class<T>) responseType : null;
this.messageConverters = messageConverters;
this.logger = logger;
}
/**
* Create a custom CustomAnnotationTransactionAttributeSource.
*
* @param annotationParsers the TransactionAnnotationParsers to use
*/
public CustomAnnotationTransactionAttributeSource(
TransactionAnnotationParser... annotationParsers) {
this.publicMethodsOnly = true;
Assert.notEmpty(
annotationParsers, "At least one TransactionAnnotationParser needs to be specified");
Set<TransactionAnnotationParser> parsers =
new LinkedHashSet<TransactionAnnotationParser>(annotationParsers.length);
Collections.addAll(parsers, annotationParsers);
this.annotationParsers = parsers;
}
@Override
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
for (String basePackage : basePackages) {
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
ScannedGenericBeanDefinition bd = (ScannedGenericBeanDefinition) candidate; // 通用bean扫描
bd.setBeanClassName(HessianServiceExporter.class.getName()); // 设置bean名称
bd.setBeanClass(HessianServiceExporter.class); // 设置bean类
bd.getPropertyValues().add("service", registry.getBeanDefinition(beanName)); // 设置属性 service
String[] interfaces = bd.getMetadata().getInterfaceNames(); // 获得元数据、接口名称
if (interfaces == null || interfaces.length == 0) continue;
Class interf = null;
try {
interf = Class.forName(interfaces[0]); // 获得接口
} catch (ClassNotFoundException e) {
continue;
}
bd.getPropertyValues().add("serviceInterface", interf); // 设置属性 serviceInterface
candidate = bd;
BeanDefinitionHolder definitionHolder =
new BeanDefinitionHolder(candidate, "/" + beanName); // 新bean定义持有
definitionHolder =
applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry); // 应用范围代理模式
beanDefinitions.add(definitionHolder); // 将bean定义持有放入bean定义持有set中
registerBeanDefinition(definitionHolder, this.registry); // 注册bean定义
}
}
if (beanDefinitions.isEmpty()) {
System.out.println("not service be scaned");
} else {
for (BeanDefinitionHolder holder : beanDefinitions) {
AnnotatedBeanDefinition definition =
(AnnotatedBeanDefinition) holder.getBeanDefinition(); // 注释的bean定义
System.out.println("service:" + holder.getBeanName()); // 注释的bean定义名称
System.out.println(
"service:" + definition.getMetadata().getAnnotationTypes()); // 注释的bean定义类型
}
}
return beanDefinitions;
}
@Test
public void testGetUserRoleList() {
Assert.notNull(client);
User u = new User();
u.setId(1L);
List<Role> list = client.getUserRoleList(u);
Assert.notEmpty(list);
for (Role r : list) {
logger.info("role name: " + r.getName());
}
}
// TODO: Extract this into some utility, as it comes in handy in several places
private String join(String... strings) {
Assert.notEmpty(strings);
StringBuilder builder = new StringBuilder();
builder.append(strings[0]);
if (strings.length > 1) {
for (int i = 1; i < strings.length; i++) {
builder.append(",").append(strings[i]);
}
}
return builder.toString();
}
public JythonScriptFactory(
String scriptSourceLocator, Class[] scriptInterfaces, Object[] arguments) {
Assert.hasText(scriptSourceLocator);
Assert.notEmpty(scriptInterfaces);
this.scriptSourceLocator = scriptSourceLocator;
this.scriptInterfaces = scriptInterfaces;
if (arguments == null || arguments.length == 0) {
this.arguments = null;
} else {
this.arguments = arguments;
}
}
