proj_name
stringclasses 131
values | relative_path
stringlengths 30
228
| class_name
stringlengths 1
68
| func_name
stringlengths 1
48
| masked_class
stringlengths 78
9.82k
| func_body
stringlengths 46
9.61k
| len_input
int64 29
2.01k
| len_output
int64 14
1.94k
| total
int64 55
2.05k
| relevant_context
stringlengths 0
38.4k
|
|---|---|---|---|---|---|---|---|---|---|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/jpa/JpaJobConfiguration.java
|
JpaJobConfiguration
|
job
|
class JpaJobConfiguration {
@Bean
public JpaPagingItemReader<CustomerCredit> itemReader(EntityManagerFactory entityManagerFactory) {
return new JpaPagingItemReaderBuilder<CustomerCredit>().name("itemReader")
.entityManagerFactory(entityManagerFactory)
.queryString("select c from CustomerCredit c")
.build();
}
@Bean
public JpaItemWriter<CustomerCredit> itemWriter(EntityManagerFactory entityManagerFactory) {
return new JpaItemWriterBuilder<CustomerCredit>().entityManagerFactory(entityManagerFactory).build();
}
@Bean
public Job job(JobRepository jobRepository, JpaTransactionManager jpaTransactionManager,
JpaPagingItemReader<CustomerCredit> itemReader, JpaItemWriter<CustomerCredit> itemWriter) {<FILL_FUNCTION_BODY>}
// Infrastructure beans
@Bean
public JpaTransactionManager jpaTransactionManager(EntityManagerFactory entityManagerFactory) {
return new JpaTransactionManager(entityManagerFactory);
}
@Bean
public EntityManagerFactory entityManagerFactory(PersistenceUnitManager persistenceUnitManager,
DataSource dataSource) {
LocalContainerEntityManagerFactoryBean factoryBean = new LocalContainerEntityManagerFactoryBean();
factoryBean.setDataSource(dataSource);
factoryBean.setPersistenceUnitManager(persistenceUnitManager);
factoryBean.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
factoryBean.afterPropertiesSet();
return factoryBean.getObject();
}
@Bean
public PersistenceUnitManager persistenceUnitManager(DataSource dataSource) {
DefaultPersistenceUnitManager persistenceUnitManager = new DefaultPersistenceUnitManager();
persistenceUnitManager.setDefaultDataSource(dataSource);
persistenceUnitManager.afterPropertiesSet();
return persistenceUnitManager;
}
}
|
return new JobBuilder("ioSampleJob", jobRepository)
.start(new StepBuilder("step1", jobRepository)
.<CustomerCredit, CustomerCredit>chunk(2, jpaTransactionManager)
.reader(itemReader)
.processor(new CustomerCreditIncreaseProcessor())
.writer(itemWriter)
.build())
.build();
| 460
| 94
| 554
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/jpa/JpaRepositoryJobConfiguration.java
|
JpaRepositoryJobConfiguration
|
entityManagerFactory
|
class JpaRepositoryJobConfiguration {
@Bean
@StepScope
public RepositoryItemReader<CustomerCredit> itemReader(@Value("#{jobParameters['credit']}") Double credit,
CustomerCreditPagingAndSortingRepository repository) {
return new RepositoryItemReaderBuilder<CustomerCredit>().name("itemReader")
.pageSize(2)
.methodName("findByCreditGreaterThan")
.repository(repository)
.arguments(BigDecimal.valueOf(credit))
.sorts(Map.of("id", Sort.Direction.ASC))
.build();
}
@Bean
public RepositoryItemWriter<CustomerCredit> itemWriter(CustomerCreditCrudRepository repository) {
return new RepositoryItemWriterBuilder<CustomerCredit>().repository(repository).methodName("save").build();
}
@Bean
public Job job(JobRepository jobRepository, JpaTransactionManager jpaTransactionManager,
RepositoryItemReader<CustomerCredit> itemReader, RepositoryItemWriter<CustomerCredit> itemWriter) {
return new JobBuilder("ioSampleJob", jobRepository)
.start(new StepBuilder("step1", jobRepository)
.<CustomerCredit, CustomerCredit>chunk(2, jpaTransactionManager)
.reader(itemReader)
.processor(new CustomerCreditIncreaseProcessor())
.writer(itemWriter)
.build())
.build();
}
// Infrastructure beans
@Bean
public JpaTransactionManager jpaTransactionManager(EntityManagerFactory entityManagerFactory) {
return new JpaTransactionManager(entityManagerFactory);
}
@Bean
public EntityManagerFactory entityManagerFactory(PersistenceUnitManager persistenceUnitManager,
DataSource dataSource) {<FILL_FUNCTION_BODY>}
@Bean
public PersistenceUnitManager persistenceUnitManager(DataSource dataSource) {
DefaultPersistenceUnitManager persistenceUnitManager = new DefaultPersistenceUnitManager();
persistenceUnitManager.setDefaultDataSource(dataSource);
persistenceUnitManager.afterPropertiesSet();
return persistenceUnitManager;
}
}
|
LocalContainerEntityManagerFactoryBean factoryBean = new LocalContainerEntityManagerFactoryBean();
factoryBean.setDataSource(dataSource);
factoryBean.setPersistenceUnitManager(persistenceUnitManager);
factoryBean.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
factoryBean.afterPropertiesSet();
return factoryBean.getObject();
| 519
| 95
| 614
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/launch/DefaultJobLoader.java
|
DefaultJobLoader
|
setProperty
|
class DefaultJobLoader implements JobLoader, ApplicationContextAware {
private ListableJobLocator registry;
private ApplicationContext applicationContext;
private final Map<String, String> configurations = new HashMap<>();
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
public void setRegistry(ListableJobLocator registry) {
this.registry = registry;
}
@Override
public Map<String, String> getConfigurations() {
Map<String, String> result = new HashMap<>(configurations);
for (String jobName : registry.getJobNames()) {
try {
Job configuration = registry.getJob(jobName);
String name = configuration.getName();
if (!configurations.containsKey(name)) {
result.put(name, "<unknown path>: " + configuration);
}
}
catch (NoSuchJobException e) {
throw new IllegalStateException("Registry could not locate its own job (NoSuchJobException).", e);
}
}
return result;
}
@Override
@SuppressWarnings("resource")
public void loadResource(String path) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[] { path },
applicationContext);
String[] names = context.getBeanNamesForType(Job.class);
for (String name : names) {
configurations.put(name, path);
}
}
@Override
public Object getJobConfiguration(String name) {
try {
return registry.getJob(name);
}
catch (NoSuchJobException e) {
return null;
}
}
@Override
public Object getProperty(String path) {
int index = PropertyAccessorUtils.getFirstNestedPropertySeparatorIndex(path);
BeanWrapperImpl wrapper = createBeanWrapper(path, index);
String key = path.substring(index + 1);
return wrapper.getPropertyValue(key);
}
@Override
public void setProperty(String path, String value) {<FILL_FUNCTION_BODY>}
private BeanWrapperImpl createBeanWrapper(String path, int index) {
Assert.state(index > 0, "Path must be nested, e.g. bean.value");
String name = path.substring(0, index);
Object bean = getJobConfiguration(name);
Assert.notNull(bean, "No JobConfiguration exists with name=" + name);
return new BeanWrapperImpl(bean);
}
}
|
int index = PropertyAccessorUtils.getFirstNestedPropertySeparatorIndex(path);
BeanWrapperImpl wrapper = createBeanWrapper(path, index);
String key = path.substring(index + 1);
wrapper.setPropertyValue(key, value);
| 646
| 67
| 713
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/loom/JobConfigurationForAsynchronousItemProcessingWithVirtualThreads.java
|
JobConfigurationForAsynchronousItemProcessingWithVirtualThreads
|
itemProcessor
|
class JobConfigurationForAsynchronousItemProcessingWithVirtualThreads {
@Bean
public ItemReader<Integer> itemReader() {
return new ListItemReader<>(Arrays.asList(0, 1, 2, 3, 4, 5));
}
@Bean
public AsyncItemProcessor<Integer, Integer> itemProcessor() {<FILL_FUNCTION_BODY>}
@Bean
public AsyncItemWriter<Integer> itemWriter() {
AsyncItemWriter<Integer> asyncItemWriter = new AsyncItemWriter<>();
asyncItemWriter.setDelegate(items -> {
for (Integer item : items) {
System.out.println(Thread.currentThread() + ": writing item " + item);
}
});
return asyncItemWriter;
}
@Bean
public Job job(JobRepository jobRepository, JdbcTransactionManager transactionManager,
ItemReader<Integer> itemReader, AsyncItemProcessor<Integer, Integer> itemProcessor,
AsyncItemWriter<Integer> itemWriter) {
Step step = new StepBuilder("step", jobRepository).<Integer, Future<Integer>>chunk(2, transactionManager)
.reader(itemReader)
.processor(itemProcessor)
.writer(itemWriter)
.build();
return new JobBuilder("job", jobRepository).start(step).build();
}
}
|
AsyncItemProcessor<Integer, Integer> asyncItemProcessor = new AsyncItemProcessor<>();
asyncItemProcessor.setDelegate(item -> {
System.out.println(Thread.currentThread() + ": processing item " + item);
return item + 1;
});
asyncItemProcessor.setTaskExecutor(new VirtualThreadTaskExecutor("spring-batch-"));
return asyncItemProcessor;
| 333
| 101
| 434
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/loom/JobConfigurationForLaunchingJobsWithVirtualThreads.java
|
JobConfigurationForLaunchingJobsWithVirtualThreads
|
job
|
class JobConfigurationForLaunchingJobsWithVirtualThreads {
@Bean
public Job job(JobRepository jobRepository, JdbcTransactionManager transactionManager) {<FILL_FUNCTION_BODY>}
@Bean
public TaskExecutor taskExecutor() {
return new VirtualThreadTaskExecutor("spring-batch-");
}
}
|
Step step = new StepBuilder("step", jobRepository).tasklet((contribution, chunkContext) -> {
String message = Thread.currentThread() + ": Hello virtual threads world!";
contribution.getStepExecution().getJobExecution().getExecutionContext().put("message", message);
return RepeatStatus.FINISHED;
}, transactionManager).build();
return new JobBuilder("job", jobRepository).start(step).build();
| 80
| 112
| 192
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/loom/JobConfigurationForRunningConcurrentStepsWithVirtualThreads.java
|
JobConfigurationForRunningConcurrentStepsWithVirtualThreads
|
job
|
class JobConfigurationForRunningConcurrentStepsWithVirtualThreads {
@Bean
public ItemReader<Integer> itemReader() {
return new ListItemReader<>(Arrays.asList(1, 2, 3, 4, 5, 6)) {
final Lock lock = new ReentrantLock();
@Override
public Integer read() {
this.lock.lock();
try {
Integer item = super.read();
System.out.println(Thread.currentThread() + ": reading item " + item);
return item;
}
finally {
this.lock.unlock();
}
}
};
}
@Bean
public ItemWriter<Integer> itemWriter() {
return items -> {
for (Integer item : items) {
System.out.println(Thread.currentThread() + ": writing item " + item);
}
};
}
@Bean
public Job job(JobRepository jobRepository, JdbcTransactionManager transactionManager,
ItemReader<Integer> itemReader, ItemWriter<Integer> itemWriter) {<FILL_FUNCTION_BODY>}
}
|
Step step = new StepBuilder("step", jobRepository).<Integer, Integer>chunk(2, transactionManager)
.reader(itemReader)
.writer(itemWriter)
.taskExecutor(new VirtualThreadTaskExecutor("spring-batch-"))
.build();
return new JobBuilder("job", jobRepository).start(step).build();
| 286
| 87
| 373
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/loom/JobConfigurationForRunningParallelStepsWithVirtualThreads.java
|
JobConfigurationForRunningParallelStepsWithVirtualThreads
|
job
|
class JobConfigurationForRunningParallelStepsWithVirtualThreads {
@Bean
public Step step1(JobRepository jobRepository, JdbcTransactionManager transactionManager) {
return createStep("step1", jobRepository, transactionManager);
}
@Bean
public Step step2(JobRepository jobRepository, JdbcTransactionManager transactionManager) {
return createStep("step2", jobRepository, transactionManager);
}
@Bean
public Job job(JobRepository jobRepository, Step step1, Step step2) {<FILL_FUNCTION_BODY>}
private Step createStep(String stepName, JobRepository jobRepository, JdbcTransactionManager transactionManager) {
return new StepBuilder(stepName, jobRepository).tasklet((contribution, chunkContext) -> {
System.out.println(Thread.currentThread() + ": running " + stepName);
return RepeatStatus.FINISHED;
}, transactionManager).build();
}
}
|
Flow flow1 = new FlowBuilder<Flow>("subflow1").from(step1).end();
Flow flow2 = new FlowBuilder<Flow>("subflow2").from(step2).end();
Flow splitFlow = new FlowBuilder<Flow>("splitflow").split(new VirtualThreadTaskExecutor("spring-batch-"))
.add(flow1, flow2)
.build();
return new JobBuilder("job", jobRepository).start(splitFlow).build().build();
| 227
| 122
| 349
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/loom/JobConfigurationForRunningPartitionedStepsWithVirtualThreads.java
|
JobConfigurationForRunningPartitionedStepsWithVirtualThreads
|
tasklet
|
class JobConfigurationForRunningPartitionedStepsWithVirtualThreads {
@Bean
public Step managerStep(JobRepository jobRepository, Step workerStep, Partitioner partitioner) {
return new StepBuilder("managerStep", jobRepository).partitioner(workerStep.getName(), partitioner)
.step(workerStep)
.gridSize(4)
.taskExecutor(new VirtualThreadTaskExecutor("spring-batch-"))
.build();
}
@Bean
public Step workerStep(JobRepository jobRepository, JdbcTransactionManager transactionManager, Tasklet tasklet) {
return new StepBuilder("workerStep", jobRepository).tasklet(tasklet, transactionManager).build();
}
@Bean
@StepScope
public Tasklet tasklet(@Value("#{stepExecutionContext['data']}") String partitionData) {<FILL_FUNCTION_BODY>}
@Bean
public Partitioner partitioner() {
return gridSize -> {
Map<String, ExecutionContext> partitionMap = new HashMap<>(gridSize);
for (int i = 0; i < gridSize; i++) {
ExecutionContext executionContext = new ExecutionContext();
executionContext.put("data", "data" + i);
String key = "partition" + i;
partitionMap.put(key, executionContext);
}
return partitionMap;
};
}
@Bean
public Job job(JobRepository jobRepository, Step managerStep) {
return new JobBuilder("job", jobRepository).start(managerStep).build();
}
}
|
return (contribution, chunkContext) -> {
System.out.println(Thread.currentThread() + ": processing partition " + partitionData);
return RepeatStatus.FINISHED;
};
| 373
| 55
| 428
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/loom/JobConfigurationForRunningSystemCommandTaskletsWithVirtualThreads.java
|
JobConfigurationForRunningSystemCommandTaskletsWithVirtualThreads
|
tasklet
|
class JobConfigurationForRunningSystemCommandTaskletsWithVirtualThreads {
@Bean
public SystemCommandTasklet tasklet() {<FILL_FUNCTION_BODY>}
@Bean
public Job job(JobRepository jobRepository, JdbcTransactionManager transactionManager, SystemCommandTasklet tasklet)
throws Exception {
Step step = new StepBuilder("step", jobRepository).tasklet(tasklet, transactionManager).build();
return new JobBuilder("job", jobRepository).start(step).build();
}
}
|
SystemCommandTasklet systemCommandTasklet = new SystemCommandTasklet();
systemCommandTasklet.setCommand("java", "-version");
systemCommandTasklet.setCommandRunner(new JvmCommandRunner() {
@Override
public Process exec(String[] command, String[] envp, File dir) throws IOException {
System.out.println(Thread.currentThread() + ": running command " + Arrays.toString(command));
return super.exec(command, envp, dir);
}
});
systemCommandTasklet.setTaskExecutor(new VirtualThreadTaskExecutor("spring-batch-"));
systemCommandTasklet.setTimeout(1000L);
return systemCommandTasklet;
| 124
| 177
| 301
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/loop/LimitDecider.java
|
LimitDecider
|
decide
|
class LimitDecider implements JobExecutionDecider {
private int count = 0;
private int limit = 1;
@Override
public FlowExecutionStatus decide(JobExecution jobExecution, @Nullable StepExecution stepExecution) {<FILL_FUNCTION_BODY>}
/**
* @param limit number of times to return "CONTINUE"
*/
public void setLimit(int limit) {
this.limit = limit;
}
}
|
if (++count >= limit) {
return new FlowExecutionStatus("COMPLETED");
}
else {
return new FlowExecutionStatus("CONTINUE");
}
| 109
| 47
| 156
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/mail/TestMailSender.java
|
TestMailSender
|
send
|
class TestMailSender implements MailSender {
private List<String> subjectsToFail = new ArrayList<>();
private final List<SimpleMailMessage> received = new ArrayList<>();
public void clear() {
received.clear();
}
@Override
public void send(SimpleMailMessage simpleMessage) throws MailException {
throw new UnsupportedOperationException("Not implemented. Use send(SimpleMailMessage[]).");
}
public void setSubjectsToFail(List<String> subjectsToFail) {
this.subjectsToFail = subjectsToFail;
}
@Override
public void send(SimpleMailMessage... simpleMessages) throws MailException {<FILL_FUNCTION_BODY>}
public List<SimpleMailMessage> getReceivedMessages() {
return received;
}
}
|
Map<Object, Exception> failedMessages = new LinkedHashMap<>();
for (SimpleMailMessage simpleMessage : simpleMessages) {
if (subjectsToFail.contains(simpleMessage.getSubject())) {
failedMessages.put(simpleMessage, new MessagingException());
}
else {
received.add(simpleMessage);
}
}
if (!failedMessages.isEmpty()) {
throw new MailSendException(failedMessages);
}
| 193
| 117
| 310
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/mail/UserMailItemProcessor.java
|
UserMailItemProcessor
|
process
|
class UserMailItemProcessor implements ItemProcessor<User, SimpleMailMessage> {
/**
* @see org.springframework.batch.item.ItemProcessor#process(java.lang.Object)
*/
@Nullable
@Override
public SimpleMailMessage process(User user) throws Exception {<FILL_FUNCTION_BODY>}
}
|
SimpleMailMessage message = new SimpleMailMessage();
message.setTo(user.getEmail());
message.setFrom("communications@thecompany.com");
message.setSubject(user.getName() + "'s Account Info");
message.setSentDate(new Date());
message.setText("Hello " + user.getName());
return message;
| 81
| 94
| 175
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/metrics/Job1Configuration.java
|
Job1Configuration
|
step2
|
class Job1Configuration {
private final Random random;
public Job1Configuration() {
this.random = new Random();
}
@Bean
public Job job1(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
return new JobBuilder("job1", jobRepository).start(step1(jobRepository, transactionManager))
.next(step2(jobRepository, transactionManager))
.build();
}
@Bean
public Step step1(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
return new StepBuilder("step1", jobRepository).tasklet((contribution, chunkContext) -> {
System.out.println("hello");
// simulate processing time
Thread.sleep(random.nextInt(3000));
return RepeatStatus.FINISHED;
}, transactionManager).build();
}
@Bean
public Step step2(JobRepository jobRepository, PlatformTransactionManager transactionManager) {<FILL_FUNCTION_BODY>}
}
|
return new StepBuilder("step2", jobRepository).tasklet((contribution, chunkContext) -> {
System.out.println("world");
// simulate step failure
int nextInt = random.nextInt(3000);
Thread.sleep(nextInt);
if (nextInt % 5 == 0) {
throw new Exception("Boom!");
}
return RepeatStatus.FINISHED;
}, transactionManager).build();
| 239
| 118
| 357
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/metrics/Job2Configuration.java
|
Job2Configuration
|
itemReader
|
class Job2Configuration {
private final Random random;
public Job2Configuration() {
this.random = new Random();
}
@Bean
public Job job2(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
return new JobBuilder("job2", jobRepository).start(step(jobRepository, transactionManager)).build();
}
@Bean
public Step step(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
return new StepBuilder("step1", jobRepository).<Integer, Integer>chunk(3, transactionManager)
.reader(itemReader())
.writer(itemWriter())
.build();
}
@Bean
@StepScope
public ListItemReader<Integer> itemReader() {<FILL_FUNCTION_BODY>}
@Bean
public ItemWriter<Integer> itemWriter() {
return items -> {
for (Integer item : items) {
int nextInt = random.nextInt(1000);
Thread.sleep(nextInt);
// simulate write failure
if (nextInt % 57 == 0) {
throw new Exception("Boom!");
}
System.out.println("item = " + item);
}
};
}
}
|
List<Integer> items = new LinkedList<>();
// read a random number of items in each run
for (int i = 0; i < random.nextInt(100); i++) {
items.add(i);
}
return new ListItemReader<>(items);
| 301
| 76
| 377
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/metrics/JobScheduler.java
|
JobScheduler
|
launchJob1
|
class JobScheduler {
private final Job job1;
private final Job job2;
private final JobLauncher jobLauncher;
@Autowired
public JobScheduler(Job job1, Job job2, JobLauncher jobLauncher) {
this.job1 = job1;
this.job2 = job2;
this.jobLauncher = jobLauncher;
}
@Scheduled(cron = "*/10 * * * * *")
public void launchJob1() throws Exception {<FILL_FUNCTION_BODY>}
@Scheduled(cron = "*/15 * * * * *")
public void launchJob2() throws Exception {
JobParameters jobParameters = new JobParametersBuilder().addLong("time", System.currentTimeMillis())
.toJobParameters();
jobLauncher.run(job2, jobParameters);
}
}
|
JobParameters jobParameters = new JobParametersBuilder().addLong("time", System.currentTimeMillis())
.toJobParameters();
jobLauncher.run(job1, jobParameters);
| 218
| 51
| 269
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/metrics/PrometheusConfiguration.java
|
PrometheusConfiguration
|
init
|
class PrometheusConfiguration {
private static final Logger LOGGER = LoggerFactory.getLogger(PrometheusConfiguration.class);
@Value("${prometheus.job.name}")
private String prometheusJobName;
@Value("${prometheus.grouping.key}")
private String prometheusGroupingKey;
@Value("${prometheus.pushgateway.url}")
private String prometheusPushGatewayUrl;
private final Map<String, String> groupingKey = new HashMap<>();
private PushGateway pushGateway;
private CollectorRegistry collectorRegistry;
@PostConstruct
public void init() {<FILL_FUNCTION_BODY>}
@Scheduled(fixedRateString = "${prometheus.push.rate}")
public void pushMetrics() {
try {
pushGateway.pushAdd(collectorRegistry, prometheusJobName, groupingKey);
}
catch (Throwable ex) {
LOGGER.error("Unable to push metrics to Prometheus Push Gateway", ex);
}
}
}
|
pushGateway = new PushGateway(prometheusPushGatewayUrl);
groupingKey.put(prometheusGroupingKey, prometheusJobName);
PrometheusMeterRegistry prometheusMeterRegistry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);
collectorRegistry = prometheusMeterRegistry.getPrometheusRegistry();
Metrics.globalRegistry.add(prometheusMeterRegistry);
| 282
| 118
| 400
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/misc/jmx/InfiniteLoopWriter.java
|
InfiniteLoopWriter
|
write
|
class InfiniteLoopWriter implements StepExecutionListener, ItemWriter<Object> {
private static final Log LOG = LogFactory.getLog(InfiniteLoopWriter.class);
private StepExecution stepExecution;
private int count = 0;
/**
* @see org.springframework.batch.core.StepExecutionListener#beforeStep(StepExecution)
*/
@Override
public void beforeStep(StepExecution stepExecution) {
this.stepExecution = stepExecution;
}
public InfiniteLoopWriter() {
super();
}
@Override
public void write(Chunk<?> items) throws Exception {<FILL_FUNCTION_BODY>}
}
|
try {
Thread.sleep(500);
}
catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new IllegalStateException("Job interrupted.", e);
}
stepExecution.setWriteCount(++count);
if (LOG.isInfoEnabled()) {
LOG.info("Executing infinite loop, at count=" + count);
}
| 160
| 108
| 268
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/misc/jmx/JobExecutionNotificationPublisher.java
|
JobExecutionNotificationPublisher
|
publish
|
class JobExecutionNotificationPublisher
implements ApplicationListener<SimpleMessageApplicationEvent>, NotificationPublisherAware {
private static final Log LOG = LogFactory.getLog(JobExecutionNotificationPublisher.class);
private NotificationPublisher notificationPublisher;
private int notificationCount = 0;
/**
* Injection setter.
*
* @see org.springframework.jmx.export.notification.NotificationPublisherAware#setNotificationPublisher(org.springframework.jmx.export.notification.NotificationPublisher)
*/
@Override
public void setNotificationPublisher(NotificationPublisher notificationPublisher) {
this.notificationPublisher = notificationPublisher;
}
/**
* If the event is a {@link SimpleMessageApplicationEvent} for open and close we log
* the event at INFO level and send a JMX notification if we are also an MBean.
*
* @see ApplicationListener#onApplicationEvent(ApplicationEvent)
*/
@Override
public void onApplicationEvent(SimpleMessageApplicationEvent applicationEvent) {
String message = applicationEvent.toString();
LOG.info(message);
publish(message);
}
/**
* Publish the provided message to an external listener if there is one.
* @param message the message to publish
*/
private void publish(String message) {<FILL_FUNCTION_BODY>}
}
|
if (notificationPublisher != null) {
Notification notification = new Notification("JobExecutionApplicationEvent", this, notificationCount++,
message);
/*
* We can't create a notification with a null source, but we can set it to
* null after creation(!). We want it to be null so that Spring will replace
* it automatically with the ObjectName (in ModelMBeanNotificationPublisher).
*/
notification.setSource(null);
notificationPublisher.sendNotification(notification);
}
| 338
| 134
| 472
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/misc/jmx/SimpleMessageApplicationEvent.java
|
SimpleMessageApplicationEvent
|
toString
|
class SimpleMessageApplicationEvent extends ApplicationEvent {
private final String message;
public SimpleMessageApplicationEvent(Object source, String message) {
super(source);
this.message = message;
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "message=[" + message + "], " + super.toString();
| 75
| 21
| 96
|
<methods>public void <init>(java.lang.Object) ,public void <init>(java.lang.Object, java.time.Clock) ,public final long getTimestamp() <variables>private static final long serialVersionUID,private final long timestamp
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/misc/quartz/JobLauncherDetails.java
|
JobLauncherDetails
|
getJobParametersFromJobMap
|
class JobLauncherDetails extends QuartzJobBean {
/**
* Special key in job data map for the name of a job to run.
*/
static final String JOB_NAME = "jobName";
private static final Log log = LogFactory.getLog(JobLauncherDetails.class);
private JobLocator jobLocator;
private JobLauncher jobLauncher;
/**
* Public setter for the {@link JobLocator}.
* @param jobLocator the {@link JobLocator} to set
*/
public void setJobLocator(JobLocator jobLocator) {
this.jobLocator = jobLocator;
}
/**
* Public setter for the {@link JobLauncher}.
* @param jobLauncher the {@link JobLauncher} to set
*/
public void setJobLauncher(JobLauncher jobLauncher) {
this.jobLauncher = jobLauncher;
}
@Override
protected void executeInternal(JobExecutionContext context) {
Map<String, Object> jobDataMap = context.getMergedJobDataMap();
String jobName = (String) jobDataMap.get(JOB_NAME);
if (log.isInfoEnabled()) {
log.info("Quartz trigger firing with Spring Batch jobName=" + jobName);
}
JobParameters jobParameters = getJobParametersFromJobMap(jobDataMap);
try {
jobLauncher.run(jobLocator.getJob(jobName), jobParameters);
}
catch (JobExecutionException e) {
log.error("Could not execute job.", e);
}
}
/*
* Copy parameters that are of the correct type over to {@link JobParameters},
* ignoring jobName.
*
* @return a {@link JobParameters} instance
*/
private JobParameters getJobParametersFromJobMap(Map<String, Object> jobDataMap) {<FILL_FUNCTION_BODY>}
}
|
JobParametersBuilder builder = new JobParametersBuilder();
for (Entry<String, Object> entry : jobDataMap.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
if (value instanceof String && !key.equals(JOB_NAME)) {
builder.addString(key, (String) value);
}
else if (value instanceof Float || value instanceof Double) {
builder.addDouble(key, ((Number) value).doubleValue());
}
else if (value instanceof Integer || value instanceof Long) {
builder.addLong(key, ((Number) value).longValue());
}
else if (value instanceof Date) {
builder.addDate(key, (Date) value);
}
else {
log.debug("JobDataMap contains values which are not job parameters (ignoring).");
}
}
return builder.toJobParameters();
| 486
| 237
| 723
|
<methods>public void <init>() ,public final void execute(org.quartz.JobExecutionContext) throws org.quartz.JobExecutionException<variables>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/mongodb/DeletionJobConfiguration.java
|
DeletionJobConfiguration
|
deletionStep
|
class DeletionJobConfiguration {
@Bean
public MongoItemReader<Person> mongoPersonReader(MongoTemplate mongoTemplate) {
Map<String, Sort.Direction> sortOptions = new HashMap<>();
sortOptions.put("name", Sort.Direction.DESC);
return new MongoItemReaderBuilder<Person>().name("personItemReader")
.collection("person_out")
.targetType(Person.class)
.template(mongoTemplate)
.query(new Query().addCriteria(where("name").is("foo3")))
.sorts(sortOptions)
.build();
}
@Bean
public MongoItemWriter<Person> mongoPersonRemover(MongoTemplate mongoTemplate) {
return new MongoItemWriterBuilder<Person>().template(mongoTemplate)
.delete(true)
.collection("person_out")
.build();
}
@Bean
public Step deletionStep(JobRepository jobRepository, PlatformTransactionManager transactionManager,
MongoItemReader<Person> mongoPersonReader, MongoItemWriter<Person> mongoPersonRemover) {<FILL_FUNCTION_BODY>}
@Bean
public Job deletionJob(JobRepository jobRepository, Step deletionStep) {
return new JobBuilder("deletionJob", jobRepository).start(deletionStep).build();
}
}
|
return new StepBuilder("step", jobRepository).<Person, Person>chunk(2, transactionManager)
.reader(mongoPersonReader)
.writer(mongoPersonRemover)
.build();
| 338
| 54
| 392
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/mongodb/InsertionJobConfiguration.java
|
InsertionJobConfiguration
|
mongoItemReader
|
class InsertionJobConfiguration {
@Bean
public MongoItemReader<Person> mongoItemReader(MongoTemplate mongoTemplate) {<FILL_FUNCTION_BODY>}
@Bean
public MongoItemWriter<Person> mongoItemWriter(MongoTemplate mongoTemplate) {
return new MongoItemWriterBuilder<Person>().template(mongoTemplate).collection("person_out").build();
}
@Bean
public Step step(JobRepository jobRepository, PlatformTransactionManager transactionManager,
MongoItemReader<Person> mongoItemReader, MongoItemWriter<Person> mongoItemWriter) {
return new StepBuilder("step", jobRepository).<Person, Person>chunk(2, transactionManager)
.reader(mongoItemReader)
.writer(mongoItemWriter)
.build();
}
@Bean
public Job insertionJob(JobRepository jobRepository, Step step) {
return new JobBuilder("insertionJob", jobRepository).start(step).build();
}
}
|
Map<String, Sort.Direction> sortOptions = new HashMap<>();
sortOptions.put("name", Sort.Direction.DESC);
return new MongoItemReaderBuilder<Person>().name("personItemReader")
.collection("person_in")
.targetType(Person.class)
.template(mongoTemplate)
.jsonQuery("{}")
.sorts(sortOptions)
.build();
| 246
| 108
| 354
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/mongodb/MongoDBConfiguration.java
|
MongoDBConfiguration
|
mongoClient
|
class MongoDBConfiguration {
@Value("${mongodb.host}")
private String mongodbHost;
@Value("${mongodb.port}")
private int mongodbPort;
@Value("${mongodb.database}")
private String mongodbDatabase;
@Bean
public MongoClient mongoClient() {<FILL_FUNCTION_BODY>}
@Bean
public MongoTemplate mongoTemplate(MongoClient mongoClient) {
return new MongoTemplate(mongoClient, "test");
}
@Bean
public MongoDatabaseFactory mongoDatabaseFactory(MongoClient mongoClient) {
return new SimpleMongoClientDatabaseFactory(mongoClient, "test");
}
@Bean
public MongoTransactionManager transactionManager(MongoDatabaseFactory mongoDatabaseFactory) {
return new MongoTransactionManager(mongoDatabaseFactory);
}
}
|
String connectionString = "mongodb://" + this.mongodbHost + ":" + this.mongodbPort + "/" + this.mongodbDatabase;
return MongoClients.create(connectionString);
| 216
| 53
| 269
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/mongodb/MongoDBSampleApp.java
|
MongoDBSampleApp
|
main
|
class MongoDBSampleApp {
public static void main(String[] args) throws Exception {<FILL_FUNCTION_BODY>}
}
|
Class<?>[] configurationClasses = { InsertionJobConfiguration.class, DeletionJobConfiguration.class,
MongoDBConfiguration.class };
ApplicationContext context = new AnnotationConfigApplicationContext(configurationClasses);
MongoTemplate mongoTemplate = context.getBean(MongoTemplate.class);
// clear collections and insert some documents in "person_in"
MongoCollection<Document> personsIn = mongoTemplate.getCollection("person_in");
MongoCollection<Document> personsOut = mongoTemplate.getCollection("person_out");
personsIn.deleteMany(new Document());
personsOut.deleteMany(new Document());
personsIn.insertMany(Arrays.asList(new Document("name", "foo1"), new Document("name", "foo2"),
new Document("name", "foo3"), new Document("name", "foo4")));
// run the insertion job
JobLauncher jobLauncher = context.getBean(JobLauncher.class);
Job insertionJob = context.getBean("insertionJob", Job.class);
jobLauncher.run(insertionJob, new JobParameters());
// check results
List<Person> persons = mongoTemplate.findAll(Person.class, "person_out");
System.out.println("Checking persons in person_out collection");
for (Person person : persons) {
System.out.println(person);
}
// run the deletion job
Job deletionJob = context.getBean("deletionJob", Job.class);
jobLauncher.run(deletionJob, new JobParameters());
// check results (foo3 should have been removed)
persons = mongoTemplate.findAll(Person.class, "person_out");
System.out.println("Checking persons in person_out collection after deleting foo3");
for (Person person : persons) {
System.out.println(person);
}
| 37
| 495
| 532
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/mongodb/Person.java
|
Person
|
toString
|
class Person {
private String id;
private String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
public String getId() {
return id;
}
// setter used for data binding if items to delete (with known IDs)
// are read from a flat file for example
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "Person{" + "id='" + id + '\'' + ", name='" + name + '\'' + '}';
| 169
| 33
| 202
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/partitioning/remote/BasicPartitioner.java
|
BasicPartitioner
|
partition
|
class BasicPartitioner extends SimplePartitioner {
private static final String PARTITION_KEY = "partition";
@Override
public Map<String, ExecutionContext> partition(int gridSize) {<FILL_FUNCTION_BODY>}
}
|
Map<String, ExecutionContext> partitions = super.partition(gridSize);
int i = 0;
for (ExecutionContext context : partitions.values()) {
context.put(PARTITION_KEY, PARTITION_KEY + (i++));
}
return partitions;
| 60
| 72
| 132
|
<methods>public non-sealed void <init>() ,public Map<java.lang.String,org.springframework.batch.item.ExecutionContext> partition(int) <variables>private static final java.lang.String PARTITION_KEY
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/partitioning/remote/DataSourceConfiguration.java
|
DataSourceConfiguration
|
dataSource
|
class DataSourceConfiguration {
@Value("${datasource.url}")
private String url;
@Value("${datasource.username}")
private String username;
@Value("${datasource.password}")
private String password;
@Bean
public DataSource dataSource() {<FILL_FUNCTION_BODY>}
@Bean
public JdbcTransactionManager transactionManager(DataSource dataSource) {
return new JdbcTransactionManager(dataSource);
}
}
|
BasicDataSource dataSource = new BasicDataSource();
dataSource.setUrl(url);
dataSource.setUsername(username);
dataSource.setPassword(password);
return dataSource;
| 123
| 57
| 180
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/partitioning/remote/aggregating/ManagerConfiguration.java
|
ManagerConfiguration
|
managerStep
|
class ManagerConfiguration {
private static final int GRID_SIZE = 3;
private final RemotePartitioningManagerStepBuilderFactory managerStepBuilderFactory;
public ManagerConfiguration(RemotePartitioningManagerStepBuilderFactory managerStepBuilderFactory) {
this.managerStepBuilderFactory = managerStepBuilderFactory;
}
/*
* Configure outbound flow (requests going to workers)
*/
@Bean
public DirectChannel requests() {
return new DirectChannel();
}
@Bean
public IntegrationFlow outboundFlow(ActiveMQConnectionFactory connectionFactory) {
return IntegrationFlow.from(requests())
.handle(Jms.outboundAdapter(connectionFactory).destination("requests"))
.get();
}
/*
* Configure inbound flow (replies coming from workers)
*/
@Bean
public DirectChannel replies() {
return new DirectChannel();
}
@Bean
public IntegrationFlow inboundFlow(ActiveMQConnectionFactory connectionFactory) {
return IntegrationFlow.from(Jms.messageDrivenChannelAdapter(connectionFactory).destination("replies"))
.channel(replies())
.get();
}
/*
* Configure the manager step
*/
@Bean
public Step managerStep() {<FILL_FUNCTION_BODY>}
@Bean
public Job remotePartitioningJob(JobRepository jobRepository) {
return new JobBuilder("remotePartitioningJob", jobRepository).start(managerStep()).build();
}
}
|
return this.managerStepBuilderFactory.get("managerStep")
.partitioner("workerStep", new BasicPartitioner())
.gridSize(GRID_SIZE)
.outputChannel(requests())
.inputChannel(replies())
.build();
| 358
| 66
| 424
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/partitioning/remote/aggregating/WorkerConfiguration.java
|
WorkerConfiguration
|
tasklet
|
class WorkerConfiguration {
private final RemotePartitioningWorkerStepBuilderFactory workerStepBuilderFactory;
public WorkerConfiguration(RemotePartitioningWorkerStepBuilderFactory workerStepBuilderFactory) {
this.workerStepBuilderFactory = workerStepBuilderFactory;
}
/*
* Configure inbound flow (requests coming from the manager)
*/
@Bean
public DirectChannel requests() {
return new DirectChannel();
}
@Bean
public IntegrationFlow inboundFlow(ActiveMQConnectionFactory connectionFactory) {
return IntegrationFlow.from(Jms.messageDrivenChannelAdapter(connectionFactory).destination("requests"))
.channel(requests())
.get();
}
/*
* Configure outbound flow (replies going to the manager)
*/
@Bean
public DirectChannel replies() {
return new DirectChannel();
}
@Bean
public IntegrationFlow outboundFlow(ActiveMQConnectionFactory connectionFactory) {
return IntegrationFlow.from(replies())
.handle(Jms.outboundAdapter(connectionFactory).destination("replies"))
.get();
}
/*
* Configure the worker step
*/
@Bean
public Step workerStep(PlatformTransactionManager transactionManager) {
return this.workerStepBuilderFactory.get("workerStep")
.inputChannel(requests())
.outputChannel(replies())
.tasklet(tasklet(null), transactionManager)
.build();
}
@Bean
@StepScope
public Tasklet tasklet(@Value("#{stepExecutionContext['partition']}") String partition) {<FILL_FUNCTION_BODY>}
}
|
return (contribution, chunkContext) -> {
System.out.println("processing " + partition);
return RepeatStatus.FINISHED;
};
| 398
| 45
| 443
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/partitioning/remote/polling/WorkerConfiguration.java
|
WorkerConfiguration
|
tasklet
|
class WorkerConfiguration {
private final RemotePartitioningWorkerStepBuilderFactory workerStepBuilderFactory;
public WorkerConfiguration(RemotePartitioningWorkerStepBuilderFactory workerStepBuilderFactory) {
this.workerStepBuilderFactory = workerStepBuilderFactory;
}
/*
* Configure inbound flow (requests coming from the manager)
*/
@Bean
public DirectChannel requests() {
return new DirectChannel();
}
@Bean
public IntegrationFlow inboundFlow(ActiveMQConnectionFactory connectionFactory) {
return IntegrationFlow.from(Jms.messageDrivenChannelAdapter(connectionFactory).destination("requests"))
.channel(requests())
.get();
}
/*
* Configure the worker step
*/
@Bean
public Step workerStep(PlatformTransactionManager transactionManager) {
return this.workerStepBuilderFactory.get("workerStep")
.inputChannel(requests())
.tasklet(tasklet(null), transactionManager)
.build();
}
@Bean
@StepScope
public Tasklet tasklet(@Value("#{stepExecutionContext['partition']}") String partition) {<FILL_FUNCTION_BODY>}
}
|
return (contribution, chunkContext) -> {
System.out.println("processing " + partition);
return RepeatStatus.FINISHED;
};
| 285
| 45
| 330
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/retry/RetrySampleConfiguration.java
|
RetrySampleConfiguration
|
step
|
class RetrySampleConfiguration {
@Bean
public Job retrySample(JobRepository jobRepository, Step step) {
return new JobBuilder("retrySample", jobRepository).start(step).build();
}
@Bean
protected Step step(JobRepository jobRepository, JdbcTransactionManager transactionManager) {<FILL_FUNCTION_BODY>}
@Bean
protected GeneratingTradeItemReader reader() {
GeneratingTradeItemReader reader = new GeneratingTradeItemReader();
reader.setLimit(10);
return reader;
}
@Bean
protected RetrySampleItemWriter<Object> writer() {
return new RetrySampleItemWriter<>();
}
}
|
return new StepBuilder("step", jobRepository).<Trade, Object>chunk(1, transactionManager)
.reader(reader())
.writer(writer())
.faultTolerant()
.retry(Exception.class)
.retryLimit(3)
.build();
| 171
| 76
| 247
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/skip/SkippableExceptionDuringProcessSample.java
|
SkippableExceptionDuringProcessSample
|
itemReader
|
class SkippableExceptionDuringProcessSample {
private final PlatformTransactionManager transactionManager;
public SkippableExceptionDuringProcessSample(PlatformTransactionManager transactionManager) {
this.transactionManager = transactionManager;
}
@Bean
public ItemReader<Integer> itemReader() {<FILL_FUNCTION_BODY>}
@Bean
public ItemProcessor<Integer, Integer> itemProcessor() {
return item -> {
if (item.equals(5)) {
System.out.println("Throwing exception on item " + item);
throw new IllegalArgumentException("Unable to process 5");
}
System.out.println("processing item = " + item);
return item;
};
}
@Bean
public ItemWriter<Integer> itemWriter() {
return items -> {
System.out.println("About to write chunk: " + items);
for (Integer item : items) {
System.out.println("writing item = " + item);
}
};
}
@Bean
public Step step(JobRepository jobRepository) {
return new StepBuilder("step", jobRepository).<Integer, Integer>chunk(3, this.transactionManager)
.reader(itemReader())
.processor(itemProcessor())
.writer(itemWriter())
.faultTolerant()
.skip(IllegalArgumentException.class)
.skipLimit(3)
.build();
}
@Bean
public Job job(JobRepository jobRepository) {
return new JobBuilder("job", jobRepository).start(step(jobRepository)).build();
}
}
|
return new ListItemReader<>(Arrays.asList(1, 2, 3, 4, 5, 6)) {
@Override
public Integer read() {
Integer item = super.read();
System.out.println("reading item = " + item);
return item;
}
};
| 390
| 84
| 474
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/skip/SkippableExceptionDuringReadSample.java
|
SkippableExceptionDuringReadSample
|
itemReader
|
class SkippableExceptionDuringReadSample {
private final PlatformTransactionManager transactionManager;
public SkippableExceptionDuringReadSample(PlatformTransactionManager transactionManager) {
this.transactionManager = transactionManager;
}
@Bean
public ItemReader<Integer> itemReader() {<FILL_FUNCTION_BODY>}
@Bean
public ItemProcessor<Integer, Integer> itemProcessor() {
return item -> {
System.out.println("processing item = " + item);
return item;
};
}
@Bean
public ItemWriter<Integer> itemWriter() {
return items -> {
System.out.println("About to write chunk: " + items);
for (Integer item : items) {
System.out.println("writing item = " + item);
}
};
}
@Bean
public Step step(JobRepository jobRepository) {
return new StepBuilder("step", jobRepository).<Integer, Integer>chunk(3, this.transactionManager)
.reader(itemReader())
.processor(itemProcessor())
.writer(itemWriter())
.faultTolerant()
.skip(IllegalArgumentException.class)
.skipLimit(3)
.build();
}
@Bean
public Job job(JobRepository jobRepository) {
return new JobBuilder("job", jobRepository).start(step(jobRepository)).build();
}
}
|
return new ListItemReader<>(Arrays.asList(1, 2, 3, 4, 5, 6)) {
@Override
public Integer read() {
Integer item = super.read();
System.out.println("reading item = " + item);
if (item != null && item.equals(5)) {
System.out.println("Throwing exception on item " + item);
throw new IllegalArgumentException("Sorry, no 5 here!");
}
return item;
}
};
| 343
| 137
| 480
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/skip/SkippableExceptionDuringWriteSample.java
|
SkippableExceptionDuringWriteSample
|
read
|
class SkippableExceptionDuringWriteSample {
private final PlatformTransactionManager transactionManager;
public SkippableExceptionDuringWriteSample(PlatformTransactionManager transactionManager) {
this.transactionManager = transactionManager;
}
@Bean
public ItemReader<Integer> itemReader() {
return new ListItemReader<>(Arrays.asList(1, 2, 3, 4, 5, 6)) {
@Override
public Integer read() {<FILL_FUNCTION_BODY>}
};
}
@Bean
public ItemProcessor<Integer, Integer> itemProcessor() {
return item -> {
System.out.println("processing item = " + item);
return item;
};
}
@Bean
public ItemWriter<Integer> itemWriter() {
return items -> {
System.out.println("About to write chunk: " + items);
for (Integer item : items) {
if (item.equals(5)) {
System.out.println("Throwing exception on item " + item);
throw new IllegalArgumentException("Sorry, no 5 here!");
}
System.out.println("writing item = " + item);
}
};
}
@Bean
public Step step(JobRepository jobRepository) {
return new StepBuilder("step", jobRepository).<Integer, Integer>chunk(3, this.transactionManager)
.reader(itemReader())
.processor(itemProcessor())
.writer(itemWriter())
.faultTolerant()
.skip(IllegalArgumentException.class)
.skipLimit(3)
.build();
}
@Bean
public Job job(JobRepository jobRepository) {
return new JobBuilder("job", jobRepository).start(step(jobRepository)).build();
}
}
|
Integer item = super.read();
System.out.println("reading item = " + item);
return item;
| 440
| 34
| 474
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/support/ExceptionThrowingItemReaderProxy.java
|
ExceptionThrowingItemReaderProxy
|
read
|
class ExceptionThrowingItemReaderProxy<T> implements ItemReader<T> {
private int counter = 0;
private int throwExceptionOnRecordNumber = 4;
private ItemReader<T> delegate;
/**
* @param throwExceptionOnRecordNumber The number of record on which exception should
* be thrown
*/
public void setThrowExceptionOnRecordNumber(int throwExceptionOnRecordNumber) {
this.throwExceptionOnRecordNumber = throwExceptionOnRecordNumber;
}
@Nullable
@Override
public T read() throws Exception {<FILL_FUNCTION_BODY>}
public void setDelegate(ItemReader<T> delegate) {
this.delegate = delegate;
}
}
|
counter++;
if (counter == throwExceptionOnRecordNumber) {
throw new UnexpectedJobExecutionException("Planned failure on count=" + counter);
}
return delegate.read();
| 170
| 56
| 226
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/support/HeaderCopyCallback.java
|
HeaderCopyCallback
|
handleLine
|
class HeaderCopyCallback implements LineCallbackHandler, FlatFileHeaderCallback {
private String header = "";
@Override
public void handleLine(String line) {<FILL_FUNCTION_BODY>}
@Override
public void writeHeader(Writer writer) throws IOException {
writer.write("header from input: " + header);
}
}
|
Assert.notNull(line, "line must not be null");
this.header = line;
| 85
| 28
| 113
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/support/RetrySampleItemWriter.java
|
RetrySampleItemWriter
|
write
|
class RetrySampleItemWriter<T> implements ItemWriter<T> {
private int counter = 0;
@Override
public void write(Chunk<? extends T> items) throws Exception {<FILL_FUNCTION_BODY>}
/**
* @return number of times {@link #write(Chunk)} method was called.
*/
public int getCounter() {
return counter;
}
}
|
int current = counter;
counter += items.size();
if (current < 3 && (counter >= 2 || counter >= 3)) {
throw new IllegalStateException("Temporary error");
}
| 101
| 53
| 154
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/support/SummaryFooterCallback.java
|
SummaryFooterCallback
|
writeFooter
|
class SummaryFooterCallback implements StepExecutionListener, FlatFileFooterCallback {
private StepExecution stepExecution;
@Override
public void writeFooter(Writer writer) throws IOException {<FILL_FUNCTION_BODY>}
@Override
public void beforeStep(StepExecution stepExecution) {
this.stepExecution = stepExecution;
}
}
|
writer.write("footer - number of items written: " + stepExecution.getWriteCount());
| 85
| 26
| 111
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/validation/ValidationSampleConfiguration.java
|
ValidationSampleConfiguration
|
itemReader
|
class ValidationSampleConfiguration {
@Bean
public ListItemReader<Person> itemReader() {<FILL_FUNCTION_BODY>}
@Bean
public ListItemWriter<Person> itemWriter() {
return new ListItemWriter<>();
}
@Bean
public BeanValidatingItemProcessor<Person> itemValidator() throws Exception {
BeanValidatingItemProcessor<Person> validator = new BeanValidatingItemProcessor<>();
validator.setFilter(true);
validator.afterPropertiesSet();
return validator;
}
@Bean
public Step step(JobRepository jobRepository, JdbcTransactionManager transactionManager) throws Exception {
return new StepBuilder("step", jobRepository).<Person, Person>chunk(1, transactionManager)
.reader(itemReader())
.processor(itemValidator())
.writer(itemWriter())
.build();
}
@Bean
public Job job(JobRepository jobRepository, Step step) throws Exception {
return new JobBuilder("job", jobRepository).start(step).build();
}
}
|
Person person1 = new Person(1, "foo");
Person person2 = new Person(2, "");
return new ListItemReader<>(Arrays.asList(person1, person2));
| 259
| 53
| 312
|
<no_super_class>
|
spring-projects_spring-batch
|
spring-batch/spring-batch-samples/src/main/java/org/springframework/batch/samples/validation/domain/Person.java
|
Person
|
toString
|
class Person {
private int id;
@NotEmpty
private String name;
public Person() {
}
public Person(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "Person{" + "id=" + id + ", name='" + name + '\'' + '}';
| 156
| 30
| 186
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/javastack-spring-boot-starter-sample/src/main/java/cn/javastack/springboot/starter/sample/Application.java
|
Application
|
commandLineRunner
|
class Application {
@Value("${debug}")
private boolean debug;
public static void main(String[] args) {
SpringApplication.run(Application.class);
}
@Bean
public CommandLineRunner commandLineRunner(TestService testService) {<FILL_FUNCTION_BODY>}
}
|
return (args) -> {
log.info("debug mode: {}", debug);
log.info(testService.getServiceName());
};
| 84
| 41
| 125
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-actuator/src/main/java/cn/javastack/springboot/actuator/SecurityConfig.java
|
SecurityConfig
|
securityFilterChain
|
class SecurityConfig {
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {<FILL_FUNCTION_BODY>}
@Bean
protected UserDetailsService userDetailsService() {
InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
manager.createUser(User.withUsername("test").password("{noop}test")
.roles("ENDPOINT_ADMIN", "ADMIN", "TEST").build());
manager.createUser(User.withUsername("root").password("{noop}root")
.roles("ADMIN").build());
return manager;
}
}
|
return http.authorizeHttpRequests((authorize) -> {
authorize.requestMatchers("/").permitAll()
.requestMatchers(EndpointRequest.to("health")).hasRole("ENDPOINT_ADMIN")
.requestMatchers(EndpointRequest.toAnyEndpoint()).permitAll();
})
// .csrf(csrf -> csrf.disable())
.csrf(csrf -> csrf.ignoringRequestMatchers(EndpointRequest.toAnyEndpoint()))
.formLogin(withDefaults())
.logout().logoutSuccessUrl("/")
.and().build();
| 161
| 154
| 315
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-actuator/src/main/java/cn/javastack/springboot/actuator/endpoint/TestEndpoint.java
|
TestEndpoint
|
updateUser
|
class TestEndpoint {
@ReadOperation
public User getUser(@Selector Integer id) {
return new User(id, "james", 18);
}
@WriteOperation
public User updateUser(int id, @Nullable String name, @Nullable Integer age) {<FILL_FUNCTION_BODY>}
}
|
User user = getUser(id);
user.setName(StringUtils.defaultIfBlank(name, user.getName()));
user.setAge(ObjectUtils.defaultIfNull(age, user.getAge()));
return user;
| 84
| 62
| 146
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-actuator/src/main/java/cn/javastack/springboot/actuator/observation/IndexObservation.java
|
IndexObservation
|
observe
|
class IndexObservation {
private final ObservationRegistry observationRegistry;
public void observe() {<FILL_FUNCTION_BODY>}
}
|
Observation.createNotStarted("indexObservation", this.observationRegistry)
.lowCardinalityKeyValue("area", "cn")
.highCardinalityKeyValue("userId", "10099")
.observe(() -> {
// 执行观测时的业务逻辑
log.info("开始执行业务逻辑...");
});
| 41
| 94
| 135
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-aop/src/main/java/cn/javastack/springboot/aop/aspect/CalcAspect.java
|
CalcAspect
|
around
|
class CalcAspect {
@Pointcut("execution(* cn.javastack.springboot.aop.service.CalcService.*(..))")
private void pointcut() {
}
@Before("pointcut()")
public void before() {
System.out.println("********** @Before 前置通知");
}
@After("pointcut()")
public void after() {
System.out.println("******** @After 后置通知");
}
@AfterReturning("pointcut()")
public void afterReturning() {
System.out.println("******* @AfterReturning 返回通知");
}
@AfterThrowing("pointcut()")
public void afterThrowing() {
System.out.println("******** @AfterThrowing 异常通知");
}
@Around("pointcut()")
public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {<FILL_FUNCTION_BODY>}
}
|
Object result;
System.out.println("环绕通知之前");
result = proceedingJoinPoint.proceed();
System.out.println("环绕通知之后");
return result;
| 253
| 50
| 303
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-aop/src/main/java/cn/javastack/springboot/aop/service/CalcServiceImpl.java
|
CalcServiceImpl
|
divide
|
class CalcServiceImpl implements CalcService {
@Override
public int divide(int x, int y) {<FILL_FUNCTION_BODY>}
}
|
System.out.println("=========== CalcService 被调用了");
int result = x / y;
System.out.println("=========== CalcService 调用成功");
return result;
| 44
| 53
| 97
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-cache/src/main/java/cn/javastack/springboot/cache/CacheConfiguration.java
|
CacheConfiguration
|
myRedisCacheManagerBuilderCustomizer
|
class CacheConfiguration {
/**
* 优先配置文件中的配置
* @return
*/
@Bean
public RedisCacheManagerBuilderCustomizer myRedisCacheManagerBuilderCustomizer() {<FILL_FUNCTION_BODY>}
}
|
return (builder) -> builder
.withCacheConfiguration("calc", RedisCacheConfiguration
.defaultCacheConfig().entryTtl(Duration.ofSeconds(5)))
.withCacheConfiguration("test", RedisCacheConfiguration
.defaultCacheConfig().entryTtl(Duration.ofMinutes(10)));
| 65
| 79
| 144
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-cache/src/main/java/cn/javastack/springboot/cache/CacheService.java
|
CacheService
|
multiply
|
class CacheService {
@Cacheable("calc")
public int multiply(int a, int b) {<FILL_FUNCTION_BODY>}
}
|
int c = a * b;
log.info("{} * {} = {}", a, b, c);
return c;
| 44
| 35
| 79
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-datasource/src/main/java/cn/javastack/springboot/ds/Application.java
|
Application
|
commandLineRunner
|
class Application {
public final JdbcTemplate jdbcTemplate;
public final UserDao userDao;
public static void main(String[] args) {
SpringApplication.run(Application.class);
}
@Bean
@Transactional
public CommandLineRunner commandLineRunner() {<FILL_FUNCTION_BODY>}
}
|
return (args) -> {
String username = jdbcTemplate.queryForObject("select username from t_user where id = 2",
String.class);
log.info("query username is : {}", username);
List<Map<String, Object>> list = jdbcTemplate.queryForList("select id from t_user");
log.info("total list: {}", list.size());
userDao.update();
};
| 92
| 111
| 203
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-datasource/src/main/java/cn/javastack/springboot/ds/dao/impl/UserDaoImpl.java
|
UserDaoImpl
|
update
|
class UserDaoImpl implements UserDao {
public final JdbcTemplate jdbcTemplate;
@Transactional
@Override
public void update() {<FILL_FUNCTION_BODY>}
}
|
jdbcTemplate.execute("update t_user set username = 'Petty' where id = 1");
jdbcTemplate.execute("update t_user set username = 'Yoga' where id = 2");
throw new RuntimeException("test exception");
| 55
| 61
| 116
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-elasticsearch/src/main/java/cn/javastack/springboot/es/EsController.java
|
EsController
|
repoInsert
|
class EsController {
public static final String INDEX_JAVASTACK = "javastack";
private final ElasticsearchTemplate elasticsearchTemplate;
private final UserRepository userRepository;
@RequestMapping("/es/insert")
public User insert(@RequestParam("name") String name, @RequestParam("sex") int sex) throws InterruptedException {
// 新增
User user = new User(RandomUtils.nextInt(), name, sex);
IndexCoordinates indexCoordinates = IndexCoordinates.of(INDEX_JAVASTACK);
User save = elasticsearchTemplate.save(user, indexCoordinates);
// 可能有延迟，休眠一秒再查询
Thread.sleep(1000l);
Query query = new CriteriaQuery(Criteria.where("name").is(name));
return elasticsearchTemplate.searchOne(query, User.class, indexCoordinates).getContent();
}
@RequestMapping("/es/repo/insert")
public User repoInsert(@RequestParam("name") String name, @RequestParam("sex") int sex) {<FILL_FUNCTION_BODY>}
}
|
// 新增
User user = new User(RandomUtils.nextInt(), name, sex);
userRepository.save(user);
// 查询
return userRepository.findByName(name).get(0);
| 276
| 58
| 334
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-features/src/main/java/cn/javastack/springboot/features/Application.java
|
Application
|
main
|
class Application {
/**
* 作者：栈长
* 来源微信公众号：Java技术栈
*/
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
/**
* 作者：栈长
* 来源微信公众号：Java技术栈
*/
@Bean
@Order(500)
public CommandLineRunner commandLineRunner() {
return (args) -> {
// throw new JavastackException("Java技术栈异常");
};
}
}
|
SpringApplication springApplication = new SpringApplication(Application.class);
// 允许循环引用
springApplication.setAllowCircularReferences(true);
// 启动详细日志
springApplication.setLogStartupInfo(true);
// 图案输出模式
springApplication.setBannerMode(Banner.Mode.CONSOLE);
springApplication.run(args);
| 149
| 103
| 252
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-features/src/main/java/cn/javastack/springboot/features/analyzer/PortInUseFailureAnalyzer.java
|
PortInUseFailureAnalyzer
|
analyze
|
class PortInUseFailureAnalyzer extends AbstractFailureAnalyzer<PortInUseException> {
@Override
protected FailureAnalysis analyze(Throwable rootFailure, PortInUseException cause) {<FILL_FUNCTION_BODY>}
}
|
return new FailureAnalysis("你启动的端口 " + cause.getPort() + " 被占用了.",
"快检查下端口 " + cause.getPort() + " 被哪个程序占用了，或者强制杀掉进程.",
cause);
| 60
| 68
| 128
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-features/src/main/java/cn/javastack/springboot/features/listener/JavastackListener.java
|
JavastackListener
|
onApplicationEvent
|
class JavastackListener implements ApplicationListener<AvailabilityChangeEvent> {
@Override
public void onApplicationEvent(AvailabilityChangeEvent event) {<FILL_FUNCTION_BODY>}
}
|
log.info("监听到事件：" + event);
if (ReadinessState.ACCEPTING_TRAFFIC == event.getState()) {
log.info("应用启动完成，可以请求了……");
}
| 52
| 59
| 111
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-jasypt/src/main/java/cn/javastack/springboot/jasypt/Application.java
|
Application
|
commandLineRunner
|
class Application {
@Value("${javastack.username}")
private String username;
@Value("${javastack.password}")
private String password;
/**
* 来源微信公众号：Java技术栈
* 作者：栈长
*/
public static void main(String[] args) {
SpringApplication.run(Application.class);
}
/**
* 来源微信公众号：Java技术栈
* 作者：栈长
*/
@Bean
public CommandLineRunner commandLineRunner() {<FILL_FUNCTION_BODY>}
}
|
return (args) -> {
log.info("javastack.username = {}", username);
log.info("javastack.password = {}", password);
};
| 164
| 47
| 211
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-knife4j/src/main/java/cn/javastack/springboot/knife4j/api/Knife4jController.java
|
Knife4jController
|
login
|
class Knife4jController {
/**
* Knife4j 测试接口问好
* 来源微信公众号：Java技术栈
* 作者：栈长
*/
@ApiImplicitParam(name = "name", value = "名称", required = true)
@ApiOperation(value = "公众号Java技术栈向你问好！")
@ApiOperationSupport(order = 2, author = "栈长")
@GetMapping("/knife4j/hi")
public ResponseEntity<String> hello(@RequestParam(value = "name") String name) {
return ResponseEntity.ok("Hi:" + name);
}
/**
* Knife4j 测试接口登录
* 来源微信公众号：Java技术栈
* 作者：栈长
*/
@ApiImplicitParams({
@ApiImplicitParam(name = "username", value = "用户名", required = true),
@ApiImplicitParam(name = "password", value = "密码", required = true)
})
@ApiOperation(value = "接口登录！")
@ApiOperationSupport(order = 1, author = "栈长")
@PostMapping("/knife4j/login")
public ResponseEntity<String> login(@RequestParam(value = "username") String username,
@RequestParam(value = "password") String password) {<FILL_FUNCTION_BODY>}
}
|
if (StringUtils.isNotBlank(username) && "javastack".equals(password)) {
return ResponseEntity.ok("登录成功:" + username);
}
return ResponseEntity.ok("用户名或者密码有误:" + username);
| 364
| 65
| 429
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-knife4j/src/main/java/cn/javastack/springboot/knife4j/config/Knife4jConfiguration.java
|
Knife4jConfiguration
|
defaultDocket
|
class Knife4jConfiguration {
@Bean(value = "defaultDocket")
public Docket defaultDocket() {<FILL_FUNCTION_BODY>}
}
|
// 联系人信息
Contact contact = new Contact("公众号：Java技术栈", "https://www.javastack.cn", "xx@javastack.cn");
// 创建 Docket
Docket docket = new Docket(DocumentationType.SWAGGER_2)
.apiInfo(new ApiInfoBuilder()
.title("Knife4j 测试")
.description("Knife4j Test")
.termsOfServiceUrl("https://www.javastack.cn")
.contact(contact)
.version("1.0")
.build())
.groupName("1.x")
.select()
.apis(RequestHandlerSelectors.basePackage("cn.javastack.springboot.knife4j.api"))
.paths(PathSelectors.any())
.build();
return docket;
| 46
| 216
| 262
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-logging/src/main/java/cn/javastack/springboot/logging/Application.java
|
Application
|
commandLineRunner
|
class Application {
public static void main(String[] args) {
System.setProperty("LOG_PATH", "./logs");
System.setProperty("LOGBACK_ROLLINGPOLICY_MAX_FILE_SIZE", "1KB");
SpringApplication.run(Application.class);
}
private static final org.apache.commons.logging.Log logger1 = org.apache.commons.logging
.LogFactory
.getLog(Application.class);
private static final org.slf4j.Logger logger2 = org.slf4j.LoggerFactory
.getLogger(Application.class);
@Bean
public CommandLineRunner commandLineRunner() {<FILL_FUNCTION_BODY>}
}
|
return (args) -> {
logger1.error("commons logging error...");
logger1.warn("commons logging warn");
logger1.info("commons logging info...");
logger1.debug("commons logging debug...");
logger2.error("slf4j error...");
logger2.warn("commons logging warn");
logger2.info("slf4j info...");
logger2.debug("slf4j debug...");
};
| 183
| 116
| 299
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-mail/src/main/java/cn/javastack/springboot/mail/EmailController.java
|
EmailController
|
createMimeMsg
|
class EmailController {
private final JavaMailSender javaMailSender;
private final MailProperties mailProperties;
@RequestMapping("/sendEmail")
@ResponseBody
public boolean sendEmail(@RequestParam("email") String email,
@RequestParam("text") String text) {
try {
MimeMessage msg = createMimeMsg(email, text, "java.png");
javaMailSender.send(msg);
} catch (Exception ex) {
log.error("邮件发送失败：", ex);
return false;
}
return true;
}
/**
* 创建复杂邮件
* @param email
* @param text
* @param attachmentClassPath
* @return
* @throws MessagingException
* @throws UnsupportedEncodingException
*/
private MimeMessage createMimeMsg(String email, String text, String attachmentClassPath) throws MessagingException, UnsupportedEncodingException {<FILL_FUNCTION_BODY>}
/**
* 创建简单邮件
* @param email
* @param text
* @return
*/
private SimpleMailMessage createSimpleMsg(String email, String text) {
SimpleMailMessage msg = new SimpleMailMessage();
msg.setFrom(mailProperties.getFrom());
msg.setTo(email);
msg.setBcc(mailProperties.getBcc());
msg.setSubject(mailProperties.getSubject());
msg.setText(text);
return msg;
}
}
|
MimeMessage msg = javaMailSender.createMimeMessage();
MimeMessageHelper mimeMessageHelper = new MimeMessageHelper(msg, true);
mimeMessageHelper.setFrom(mailProperties.getFrom(), mailProperties.getPersonal());
mimeMessageHelper.setTo(email);
mimeMessageHelper.setBcc(mailProperties.getBcc());
mimeMessageHelper.setSubject(mailProperties.getSubject());
mimeMessageHelper.setText(text);
mimeMessageHelper.addAttachment("附件",
new ClassPathResource(attachmentClassPath));
return msg;
| 379
| 152
| 531
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-mongodb/src/main/java/cn/javastack/mongodb/MongoController.java
|
MongoController
|
repoInsert
|
class MongoController {
public static final String COLLECTION_NAME = "javastack";
private final MongoTemplate mongoTemplate;
private final UserRepository userRepository;
@RequestMapping("/mongo/insert")
public User insert(@RequestParam("name") String name, @RequestParam("sex") int sex) {
// 新增
User user = new User(RandomUtils.nextInt(), name, sex);
mongoTemplate.insert(user, COLLECTION_NAME);
// 查询
Query query = new Query(Criteria.where("name").is(name));
return mongoTemplate.findOne(query, User.class, COLLECTION_NAME);
}
@RequestMapping("/mongo/repo/insert")
public User repoInsert(@RequestParam("name") String name, @RequestParam("sex") int sex) {<FILL_FUNCTION_BODY>}
}
|
// 新增
User user = new User(RandomUtils.nextInt(), name, sex);
userRepository.save(user);
// 查询
return userRepository.findByName(name).get(0);
| 225
| 58
| 283
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-mybatis-plus/src/main/java/cn/javastack/springboot/mybatisplus/config/CustomMetaObjectHandler.java
|
CustomMetaObjectHandler
|
insertFill
|
class CustomMetaObjectHandler implements MetaObjectHandler {
@Override
public void insertFill(MetaObject metaObject) {<FILL_FUNCTION_BODY>}
@Override
public void updateFill(MetaObject metaObject) {
this.strictUpdateFill(metaObject, "updateTime", () -> LocalDateTime.now(), LocalDateTime.class);
}
}
|
this.strictInsertFill(metaObject, "createTime", () -> LocalDateTime.now(), LocalDateTime.class);
this.strictUpdateFill(metaObject, "updateTime", () -> LocalDateTime.now(), LocalDateTime.class);
| 94
| 59
| 153
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-mybatis-plus/src/main/java/cn/javastack/springboot/mybatisplus/service/UserServiceImpl.java
|
UserServiceImpl
|
getByUsername
|
class UserServiceImpl
extends ServiceImpl<UserMapper, UserDO> implements UserService {
private final UserMapper userMapper;
@Override
public UserDO getByUsername(String username, int type) {<FILL_FUNCTION_BODY>}
}
|
if (type == 0) {
// xml
log.info("query from xml");
return userMapper.selectByUsername(username);
} else {
// QueryWrapper
log.info("query from wrapper");
LambdaQueryWrapper<UserDO> queryWrapper = new LambdaQueryWrapper();
queryWrapper.eq(UserDO::getUsername, username);
queryWrapper.eq(UserDO::getStatus, 1);
return userMapper.selectOne(queryWrapper);
}
| 68
| 126
| 194
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-mybatis/src/main/java/cn/javastack/springboot/mybatis/controller/UserController.java
|
UserController
|
getUserInfo
|
class UserController {
private final UserMapper userMapper;
@GetMapping("/user/info/{id}")
public UserDO getUserInfo(@PathVariable("id") long id) {<FILL_FUNCTION_BODY>}
}
|
UserDO userDO = userMapper.findById(id);
log.info("userDO: {}", userDO);
return userDO;
| 62
| 38
| 100
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-properties/src/main/java/cn/javastack/springboot/properties/Application.java
|
Application
|
commandLineRunner
|
class Application {
private final DbProperties dbProperties;
private final JavastackProperties javastackProperties;
private final MemberProperties memberProperties;
private final OtherMember otherMember;
@Value("${server.port}")
private int serverPort;
public static void main(String[] args) {
SpringApplication springApplication = new SpringApplication(Application.class);
// springApplication.setAdditionalProfiles("dev", "main");
springApplication.run(args);
}
@Bean
public CommandLineRunner commandLineRunner() {<FILL_FUNCTION_BODY>}
}
|
return (args) -> {
log.info("db properties: {}", dbProperties);
log.info("javastack properties: {}", javastackProperties);
log.info("member properties: {}", memberProperties);
log.info("other member: {}", otherMember);
log.info("server.port: {}", serverPort);
};
| 157
| 90
| 247
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-quartz/src/main/java/cn/javastack/springboot/quartz/TaskConfig.java
|
TaskConfig
|
init
|
class TaskConfig {
public static final String SIMPLE_TASK = "simple-task";
private final SchedulerFactoryBean schedulerFactoryBean;
/**
* 动态添加任务
* @throws SchedulerException
*/
@PostConstruct
public void init() throws SchedulerException {<FILL_FUNCTION_BODY>}
// @Bean
public JobDetail simpleTask() {
return JobBuilder.newJob(SimpleTask.class)
.withIdentity(SIMPLE_TASK)
.withDescription("简单任务")
.storeDurably()
.build();
}
// @Bean
public Trigger simpleTaskTrigger() {
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/5 * * * * ? *");
return TriggerBuilder.newTrigger()
.withIdentity("simple-task-trigger")
.forJob(simpleTask())
.withSchedule(cronScheduleBuilder)
.build();
}
}
|
Scheduler scheduler = schedulerFactoryBean.getScheduler();
boolean exists = scheduler.checkExists(JobKey.jobKey(SIMPLE_TASK));
if (!exists) {
scheduler.scheduleJob(simpleTask(), simpleTaskTrigger());
}
| 265
| 71
| 336
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-redis/src/main/java/cn/javastack/springboot/redis/RedisController.java
|
RedisController
|
setObject
|
class RedisController {
private final StringRedisTemplate stringRedisTemplate;
@Resource(name = "stringRedisTemplate")
private ValueOperations<String, String> valueOperations;
private final RedisOptService redisOptService;
private final RedisLockService redisLockService;
@RequestMapping("/redis/set")
public String set(@RequestParam("name") String name, @RequestParam("value") String value) {
valueOperations.set(name, value);
return valueOperations.get(name);
}
@RequestMapping("/redis/setObject")
public String setObject(@RequestParam("name") String name) {<FILL_FUNCTION_BODY>}
@GetMapping("/redis/lock")
public String lock(@RequestParam("key") String key) {
for (int i = 0; i < 10; i++) {
new Thread(() -> {
redisLockService.lock(key);
try {
Thread.sleep(3000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss"));
redisLockService.unlock(key);
}
).start();
}
return "OK";
}
@GetMapping("/redis/sentinel/set")
public String sentinelSet(@RequestParam("name") String name) {
redisOptService.set("name", name, 60000);
return redisOptService.getStringValue("name");
}
}
|
User user = new User();
user.setId(RandomUtils.nextInt());
user.setName(name);
user.setBirthday(new Date());
List<String> list = new ArrayList<>();
list.add("sing");
list.add("run");
user.setInteresting(list);
Map<String, Object> map = new HashMap<>();
map.put("hasHouse", "yes");
map.put("hasCar", "no");
map.put("hasKid", "no");
user.setOthers(map);
redisOptService.set(name, user, 30000);
User userValue = (User) redisOptService.get(name);
return userValue.toString();
| 416
| 194
| 610
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-redis/src/main/java/cn/javastack/springboot/redis/config/RedisConfig.java
|
RedisConfig
|
redisTemplate
|
class RedisConfig {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {<FILL_FUNCTION_BODY>}
private RedisSerializer getJacksonSerializer() {
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
ObjectMapper.DefaultTyping.NON_FINAL);
return new GenericJackson2JsonRedisSerializer(om);
}
@Bean
public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForHash();
}
@Bean
public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForValue();
}
@Bean
public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForList();
}
@Bean
public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForSet();
}
@Bean
public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForZSet();
}
@Bean(destroyMethod = "destroy")
public RedisLockRegistry redisLockRegistry(RedisConnectionFactory redisConnectionFactory) {
return new RedisLockRegistry(redisConnectionFactory, "lock");
}
}
|
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(factory);
StringRedisSerializer stringSerializer = new StringRedisSerializer();
RedisSerializer jacksonSerializer = getJacksonSerializer();
template.setKeySerializer(stringSerializer);
template.setValueSerializer(jacksonSerializer);
template.setHashKeySerializer(stringSerializer);
template.setHashValueSerializer(jacksonSerializer);
template.setEnableTransactionSupport(true);
template.afterPropertiesSet();
return template;
| 449
| 135
| 584
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-redis/src/main/java/cn/javastack/springboot/redis/service/RedisLockService.java
|
RedisLockService
|
unlock
|
class RedisLockService {
private Logger logger = LoggerFactory.getLogger(RedisLockService.class);
private static final long DEFAULT_EXPIRE_UNUSED = 60000L;
private final RedisLockRegistry redisLockRegistry;
public void lock(String lockKey) {
Lock lock = obtainLock(lockKey);
lock.lock();
}
public boolean tryLock(String lockKey) {
Lock lock = obtainLock(lockKey);
return lock.tryLock();
}
public boolean tryLock(String lockKey, long seconds) {
Lock lock = obtainLock(lockKey);
try {
return lock.tryLock(seconds, TimeUnit.SECONDS);
} catch (InterruptedException e) {
return false;
}
}
public void unlock(String lockKey) {<FILL_FUNCTION_BODY>}
private Lock obtainLock(String lockKey) {
return redisLockRegistry.obtain(lockKey);
}
}
|
try {
Lock lock = obtainLock(lockKey);
lock.unlock();
redisLockRegistry.expireUnusedOlderThan(DEFAULT_EXPIRE_UNUSED);
} catch (Exception e) {
logger.error("分布式锁 [{}] 释放异常", lockKey, e);
}
| 261
| 83
| 344
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-redis/src/main/java/cn/javastack/springboot/redis/service/RedisOptService.java
|
RedisOptService
|
deleteKey
|
class RedisOptService {
private final RedisTemplate<String, Object> redisTemplate;
private final ValueOperations valueOperations;
private final HashOperations hashOperations;
private final ListOperations listOperations;
private final SetOperations setOperations;
private final ZSetOperations zSetOperations;
public boolean expire(String key, long milliseconds) {
if (milliseconds > 0) {
return redisTemplate.expire(key, milliseconds, TimeUnit.MILLISECONDS);
}
return false;
}
public long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
public boolean hasKey(String key) {
return redisTemplate.hasKey(key);
}
public boolean deleteKey(String... key) {<FILL_FUNCTION_BODY>}
//============================Value=============================
public Object get(String key) {
return StringUtils.isBlank(key) ? null : valueOperations.get(key);
}
public String getStringValue(String key) {
return StringUtils.isBlank(key) ? null : (String) valueOperations.get(key);
}
public void set(String key, Object value) {
valueOperations.set(key, value);
}
public void set(String key, Object value, long milliseconds) {
valueOperations.set(key, value, milliseconds, TimeUnit.MILLISECONDS);
}
public long incr(String key) {
return valueOperations.increment(key);
}
public long decr(String key) {
return valueOperations.decrement(key);
}
//================================hash=================================
public Object hashGet(String key, String item) {
return hashOperations.get(key, item);
}
public Map<Object, Object> hashGetAll(String key) {
return hashOperations.entries(key);
}
public void hmSet(String key, Map<String, Object> map) {
hashOperations.putAll(key, map);
}
public boolean hmSet(String key, Map<String, Object> map, long milliseconds) {
hmSet(key, map);
if (milliseconds > 0) {
return expire(key, milliseconds);
}
return false;
}
public void hashSet(String key, String item, Object value) {
hashOperations.put(key, item, value);
}
public void hashDelete(String key, Object... item) {
hashOperations.delete(key, item);
}
public boolean hashHasKey(String key, String item) {
return hashOperations.hasKey(key, item);
}
//============================set=============================
public Set<Object> setMembers(String key) {
return setOperations.members(key);
}
public boolean setIsMember(String key, Object value) {
return setOperations.isMember(key, value);
}
public long setAdd(String key, Object... values) {
return setOperations.add(key, values);
}
public long setAdd(String key, long milliseconds, Object... values) {
Long count = setOperations.add(key, values);
if (milliseconds > 0) {
expire(key, milliseconds);
}
return count;
}
public long setSize(String key) {
return setOperations.size(key);
}
public long setRemove(String key, Object... values) {
return setOperations.remove(key, values);
}
//===============================list=================================
public List<Object> lGet(String key, long start, long end) {
return listOperations.range(key, start, end);
}
public long listSize(String key) {
return listOperations.size(key);
}
public Object listIndex(String key, long index) {
return listOperations.index(key, index);
}
public void listRightPush(String key, Object value) {
listOperations.rightPush(key, value);
}
public boolean listRightPush(String key, Object value, long milliseconds) {
listOperations.rightPush(key, value);
if (milliseconds > 0) {
return expire(key, milliseconds);
}
return false;
}
public long listRightPushAll(String key, List<Object> value) {
return listOperations.rightPushAll(key, value);
}
public boolean listRightPushAll(String key, List<Object> value, long milliseconds) {
listOperations.rightPushAll(key, value);
if (milliseconds > 0) {
return expire(key, milliseconds);
}
return false;
}
public void listSet(String key, long index, Object value) {
listOperations.set(key, index, value);
}
public long listRemove(String key, long count, Object value) {
return listOperations.remove(key, count, value);
}
//===============================zset=================================
public boolean zsAdd(String key, Object value, double score) {
return zSetOperations.add(key, value, score);
}
}
|
if (key != null) {
int length = key.length;
if (length > 0) {
if (length == 1) {
return redisTemplate.delete(key[0]);
} else {
return redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key)) == length;
}
}
}
return false;
| 1,418
| 98
| 1,516
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-session/src/main/java/cn/javastack/springboot/session/IndexController.java
|
IndexController
|
loginSubmit
|
class IndexController {
private final HttpSession httpSession;
/**
* 登录页面
* @return
*/
@ResponseBody
@RequestMapping("/login")
public String login() {
return "login page.";
}
/**
* 登录请求
* @param username
* @return
*/
@RequestMapping("/login/submit")
public String loginSubmit(@RequestParam("username") String username) {<FILL_FUNCTION_BODY>}
/**
* 首页
* @return
*/
@ResponseBody
@RequestMapping("/index")
public String index() {
log.info("session id: {}", httpSession.getId());
return "index page.";
}
/**
* 退出登录
* @return
*/
@RequestMapping("/logout")
public String logout() {
httpSession.invalidate();
return "/login";
}
}
|
if (StringUtils.isNotBlank(username)) {
httpSession.setAttribute("username", username);
return "/index";
}
return "/login";
| 252
| 45
| 297
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-session/src/main/java/cn/javastack/springboot/session/LoginInterceptor.java
|
LoginInterceptor
|
preHandle
|
class LoginInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response,
Object handler) throws Exception {<FILL_FUNCTION_BODY>}
}
|
HttpSession session = request.getSession();
String username = (String) session.getAttribute("username");
if (StringUtils.isBlank(username)) {
response.sendRedirect("/login");
return false;
}
return true;
| 60
| 66
| 126
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-web/src/main/java/cn/javastack/springboot/web/config/SecurityConfig.java
|
SecurityConfig
|
securityFilterChain
|
class SecurityConfig {
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {<FILL_FUNCTION_BODY>}
@Bean
public UserDetailsService userDetailsService() {
InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
manager.createUser(User.withUsername("test").password("{noop}test")
.roles("ADMIN", "TEST").build());
manager.createUser(User.withUsername("root").password("{noop}root")
.roles("ADMIN").build());
return manager;
}
}
|
return http.authorizeHttpRequests((authorize) -> {
authorize.requestMatchers("/test/**").hasRole("TEST")
.requestMatchers("/**").permitAll();
})
.logout().logoutSuccessUrl("/")
.and().formLogin(withDefaults())
.build();
| 153
| 82
| 235
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-web/src/main/java/cn/javastack/springboot/web/config/WebConfig.java
|
WebConfig
|
mappingJackson2HttpMessageConverter
|
class WebConfig implements WebMvcConfigurer {
/**
* Locale 默认设置为英文
*
* @return
*/
@Bean
public LocaleResolver localeResolver() {
SessionLocaleResolver sessionLocaleResolver = new SessionLocaleResolver();
sessionLocaleResolver.setDefaultLocale(Locale.US);
return sessionLocaleResolver;
}
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(localeChangeInterceptor());
}
/**
* 切换语言拦截器，通过 url?lang=zh_CN 形式进行切换
*
* @return
*/
private LocaleChangeInterceptor localeChangeInterceptor() {
LocaleChangeInterceptor localeChangeInterceptor = new LocaleChangeInterceptor();
localeChangeInterceptor.setParamName("lang");
return localeChangeInterceptor;
}
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/static/**").addResourceLocations("classpath:/static/");
registry.addResourceHandler("/assets/**").addResourceLocations("classpath:/assets/");
}
@Override
public void addFormatters(FormatterRegistry registry) {
registry.addConverter(new CustomConverter());
}
@Bean
public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter() {<FILL_FUNCTION_BODY>}
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/user/**")
.allowedMethods("GET", "POST")
.allowedOrigins("https://javastack.cn")
.allowedHeaders("header1", "header2", "header3")
.exposedHeaders("header1", "header2")
.allowCredentials(true).maxAge(3600);
}
@Bean
public ServletRegistrationBean registerServlet() {
ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new RegisterServlet(), "/registerServlet");
servletRegistrationBean.addInitParameter("name", "registerServlet");
servletRegistrationBean.addInitParameter("sex", "man");
servletRegistrationBean.setIgnoreRegistrationFailure(true);
return servletRegistrationBean;
}
@Bean
public ServletContextInitializer servletContextInitializer() {
return (servletContext) -> {
ServletRegistration initServlet = servletContext.addServlet("initServlet", InitServlet.class);
initServlet.addMapping("/initServlet");
initServlet.setInitParameter("name", "initServlet");
initServlet.setInitParameter("sex", "man");
};
}
@Bean
public RestTemplate defaultRestTemplate(RestTemplateBuilder restTemplateBuilder) {
return restTemplateBuilder
.setConnectTimeout(Duration.ofSeconds(5))
.setReadTimeout(Duration.ofSeconds(5))
.basicAuthentication("test", "test")
.build();
}
}
|
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
SimpleModule module = new SimpleModule();
module.addDeserializer(String.class, new StringWithoutSpaceDeserializer(String.class));
mapper.registerModule(module);
converter.setObjectMapper(mapper);
return converter;
| 777
| 127
| 904
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-web/src/main/java/cn/javastack/springboot/web/controller/ResponseBodyController.java
|
ResponseBodyController
|
getXmlUserInfo
|
class ResponseBodyController {
@CrossOrigin
@GetMapping(value = "/user/json/{userId}", produces = MediaType.APPLICATION_JSON_VALUE)
public User getJsonUserInfo(@PathVariable("userId") @Size(min = 5, max = 8) String userId) {
User user = new User("Java技术栈", 18);
user.setId(Long.valueOf(userId));
log.info("user info: {}", user);
return user;
}
@GetMapping(value = "/user/xml/{userId}", produces = MediaType.APPLICATION_XML_VALUE)
public UserXml getXmlUserInfo(@PathVariable("userId") String userId) {<FILL_FUNCTION_BODY>}
@PostMapping(value = "/user/save")
public ResponseEntity saveUser(@RequestBody @Validated User user) {
user.setId(RandomUtils.nextLong());
return new ResponseEntity(user, HttpStatus.OK);
}
@GetMapping("/")
public String index() {
return "index page.";
}
}
|
UserXml user = new UserXml();
user.setName("栈长");
user.setId(userId);
List<OrderInfo> orderList = new ArrayList<>();
OrderInfo orderInfo1 = new OrderInfo("123456001", 999, new Date());
OrderInfo orderInfo2 = new OrderInfo("123456002", 777, new Date());
OrderInfo orderInfo3 = new OrderInfo("123456003", 666, new Date());
orderList.add(orderInfo1);
orderList.add(orderInfo2);
orderList.add(orderInfo3);
user.setOrderList(orderList);
return user;
| 280
| 189
| 469
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-web/src/main/java/cn/javastack/springboot/web/handler/CustomConverter.java
|
CustomConverter
|
convert
|
class CustomConverter implements Converter<String, String> {
@Override
public String convert(String source) {<FILL_FUNCTION_BODY>}
}
|
if (StringUtils.isNotEmpty(source)) {
source = source.trim();
}
return source;
| 43
| 33
| 76
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-web/src/main/java/cn/javastack/springboot/web/handler/CustomRestTemplateCustomizer.java
|
CustomRestTemplateCustomizer
|
customize
|
class CustomRestTemplateCustomizer implements RestTemplateCustomizer {
@Override
public void customize(RestTemplate restTemplate) {<FILL_FUNCTION_BODY>}
static class CustomRoutePlanner extends DefaultProxyRoutePlanner {
CustomRoutePlanner(HttpHost proxy) {
super(proxy);
}
@Override
protected HttpHost determineProxy(HttpHost target, HttpContext context) throws HttpException {
log.info("hostName is {}", target.getHostName());
if ("localhost".equals(target.getHostName())) {
return null;
}
return super.determineProxy(target, context);
}
}
}
|
HttpRoutePlanner routePlanner = new CustomRoutePlanner(new HttpHost("proxy.javastack.cn"));
RequestConfig requestConfig = RequestConfig.custom().build();
HttpClient httpClient = HttpClientBuilder.create()
.setDefaultRequestConfig(requestConfig)
.setRoutePlanner(routePlanner).build();
restTemplate.setRequestFactory(new HttpComponentsClientHttpRequestFactory(httpClient));
| 168
| 104
| 272
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-web/src/main/java/cn/javastack/springboot/web/handler/ErrorRegister.java
|
ErrorRegister
|
registerErrorPages
|
class ErrorRegister implements ErrorPageRegistrar {
@Override
public void registerErrorPages(ErrorPageRegistry registry) {<FILL_FUNCTION_BODY>}
}
|
ErrorPage err400 = new ErrorPage(HttpStatus.BAD_REQUEST, "/error");
ErrorPage err404 = new ErrorPage(HttpStatus.NOT_FOUND, "/error");
ErrorPage err500 = new ErrorPage(HttpStatus.INTERNAL_SERVER_ERROR, "/error");
registry.addErrorPages(err400, err404, err500);
| 45
| 101
| 146
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-web/src/main/java/cn/javastack/springboot/web/handler/GlobalExceptionHandler.java
|
GlobalExceptionHandler
|
handleMethodArgumentNotValidException
|
class GlobalExceptionHandler {
@ResponseBody
@ExceptionHandler(value = { Exception.class })
public ResponseEntity<?> handleException(HttpServletRequest request, Throwable ex) {
log.error("global exception:", ex);
return new ResponseEntity<>("global exception", HttpStatus.OK);
}
@ResponseBody
@ExceptionHandler(value = {MethodArgumentNotValidException.class})
public ResponseEntity handleMethodArgumentNotValidException(MethodArgumentNotValidException ex) {<FILL_FUNCTION_BODY>}
}
|
BindingResult bindingResult = ex.getBindingResult();
StringBuilder sb = new StringBuilder("参数校验失败:");
for (FieldError fieldError : bindingResult.getFieldErrors()) {
sb.append(fieldError.getField()).append("：").append(fieldError.getDefaultMessage()).append(", ");
}
String msg = sb.toString();
return new ResponseEntity(msg, HttpStatus.OK);
| 136
| 106
| 242
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-web/src/main/java/cn/javastack/springboot/web/servlet/InitServlet.java
|
InitServlet
|
service
|
class InitServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws IOException {<FILL_FUNCTION_BODY>}
}
|
String name = getServletConfig().getInitParameter("name");
String sex = getServletConfig().getInitParameter("sex");
resp.getOutputStream().println("name is " + name);
resp.getOutputStream().println("sex is " + sex);
| 47
| 65
| 112
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-web/src/main/java/cn/javastack/springboot/web/servlet/JavaFilter.java
|
JavaFilter
|
init
|
class JavaFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {<FILL_FUNCTION_BODY>}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
log.info("java filter processing.");
chain.doFilter(request, response);
}
@Override
public void destroy() {
log.info("java filter destroy.");
}
}
|
log.info("java filter init.");
String name = filterConfig.getInitParameter("name");
String code = filterConfig.getInitParameter("code");
log.info("name is " + name);
log.info("code is " + code);
| 126
| 65
| 191
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-web/src/main/java/cn/javastack/springboot/web/servlet/JavaServlet.java
|
JavaServlet
|
service
|
class JavaServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws IOException {<FILL_FUNCTION_BODY>}
}
|
String name = getServletConfig().getInitParameter("name");
String sex = getServletConfig().getInitParameter("sex");
resp.getOutputStream().println("name is " + name);
resp.getOutputStream().println("sex is " + sex);
| 47
| 65
| 112
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-web/src/main/java/cn/javastack/springboot/web/servlet/RegisterServlet.java
|
RegisterServlet
|
service
|
class RegisterServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws IOException {<FILL_FUNCTION_BODY>}
}
|
String name = getServletConfig().getInitParameter("name");
String sex = getServletConfig().getInitParameter("sex");
resp.getOutputStream().println("name is " + name);
resp.getOutputStream().println("sex is " + sex);
| 47
| 64
| 111
|
<no_super_class>
|
javastacks_spring-boot-best-practice
|
spring-boot-best-practice/spring-boot-webflux/src/main/java/cn/javastack/springboot/webflux/config/WebConfig.java
|
WebConfig
|
webClient
|
class WebConfig {
@Bean
public WebClient webClient(WebClient.Builder webClientBuilder) {<FILL_FUNCTION_BODY>}
}
|
HttpClient httpClient = HttpClient.create()
.tcpConfiguration(client ->
client.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 3)
.doOnConnected(conn -> {
conn.addHandlerLast(new ReadTimeoutHandler(3000));
conn.addHandlerLast(new WriteTimeoutHandler(3000));
})
);
ReactorClientHttpConnector connector = new ReactorClientHttpConnector(httpClient);
return webClientBuilder.clientConnector(connector).build();
| 42
| 138
| 180
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/SpringBootPlusApplication.java
|
SpringBootPlusApplication
|
main
|
class SpringBootPlusApplication {
private static final String BACKSLASH = "/";
public static void main(String[] args) throws Exception {<FILL_FUNCTION_BODY>}
/**
* 打印项目信息
*
* @param context
*/
private static void printlnProjectInfo(ConfigurableApplicationContext context) {
try {
ConfigurableEnvironment environment = context.getEnvironment();
String serverPort = environment.getProperty("server.port");
String contextPath = environment.getProperty("server.servlet.context-path");
if (!BACKSLASH.equals(contextPath)) {
contextPath = contextPath + BACKSLASH;
}
String localhostDocUrl = "\nhttp://localhost:" + serverPort + contextPath + "doc.html";
System.out.println(localhostDocUrl);
String localhostSwaggerUrl = "http://localhost:" + serverPort + contextPath + "swagger-ui/index.html";
System.out.println(localhostSwaggerUrl);
List<String> ipV4List = IpUtil.getLocalhostIpList();
if (CollectionUtils.isNotEmpty(ipV4List)) {
for (String ip : ipV4List) {
String ipUrl = "http://" + ip + ":" + serverPort + contextPath + "doc.html";
System.out.println(ipUrl);
}
}
System.out.println("\n账号：admin");
System.out.println("密码：123456");
System.out.println("swagger密码：e10adc3949ba59abbe56e057f20f883e\n");
} catch (Exception e) {
e.printStackTrace();
}
}
}
|
ConfigurableApplicationContext context = SpringApplication.run(SpringBootPlusApplication.class, args);
System.out.println(" _____ _______ _____ _______ _____ _ _ _____ _____ ______ _____ _____ \n" +
" / ____|__ __|/\\ | __ \\__ __| / ____| | | |/ ____/ ____| ____|/ ____/ ____|\n" +
"| (___ | | / \\ | |__) | | | | (___ | | | | | | | | |__ | (___| (___ \n" +
" \\___ \\ | | / /\\ \\ | _ / | | \\___ \\| | | | | | | | __| \\___ \\\\___ \\ \n" +
" ____) | | |/ ____ \\| | \\ \\ | | ____) | |__| | |___| |____| |____ ____) |___) |\n" +
"|_____/ |_/_/ \\_\\_| \\_\\ |_| |_____/ \\____/ \\_____\\_____|______|_____/_____/ \n");
// 打印项目信息
printlnProjectInfo(context);
| 451
| 314
| 765
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/auth/aop/AppDataRangeAop.java
|
AppDataRangeAop
|
doAround
|
class AppDataRangeAop {
@Around(AopConstant.APP_POINTCUT)
public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {<FILL_FUNCTION_BODY>}
}
|
Object[] args = joinPoint.getArgs();
if (ArrayUtils.isEmpty(args)) {
return joinPoint.proceed();
}
for (Object arg : args) {
if (arg instanceof DataRangeQuery) {
DataRangeQuery dataRangeQuery = (DataRangeQuery) arg;
DataRangeUtil.handleAppLogin(dataRangeQuery);
break;
}
}
return joinPoint.proceed();
| 62
| 109
| 171
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/auth/aop/CommonDataRangeAop.java
|
CommonDataRangeAop
|
doAround
|
class CommonDataRangeAop {
@Around(AopConstant.COMMON_POINTCUT)
public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {<FILL_FUNCTION_BODY>}
}
|
Object[] args = joinPoint.getArgs();
if (ArrayUtils.isEmpty(args)) {
return joinPoint.proceed();
}
for (Object arg : args) {
if (arg instanceof DataRangeQuery) {
DataRangeQuery dataRangeQuery = (DataRangeQuery) arg;
DataRangeUtil.handleCommonLogin(dataRangeQuery);
break;
}
}
return joinPoint.proceed();
| 64
| 109
| 173
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/auth/aop/DataRangeAop.java
|
DataRangeAop
|
doAround
|
class DataRangeAop {
@Around(AopConstant.ADMIN_POINTCUT)
public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {<FILL_FUNCTION_BODY>}
}
|
Object[] args = joinPoint.getArgs();
if (ArrayUtils.isEmpty(args)) {
return joinPoint.proceed();
}
for (Object arg : args) {
if (arg instanceof DataRangeQuery) {
DataRangeQuery dataRangeQuery = (DataRangeQuery) arg;
DataRangeUtil.handleAdminLogin(dataRangeQuery);
break;
}
}
return joinPoint.proceed();
| 63
| 109
| 172
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/auth/controller/AppLoginController.java
|
AppLoginController
|
login
|
class AppLoginController {
@Autowired
private AppLoginService appLoginService;
/**
* APP小程序登录
*
* @param appLoginDto
* @param response
* @return
* @throws Exception
*/
@PostMapping("/login")
@Operation(summary = "APP小程序登录")
public ApiResult<LoginTokenVo> login(@Valid @RequestBody AppLoginDto appLoginDto, HttpServletRequest request, HttpServletResponse response) {<FILL_FUNCTION_BODY>}
/**
* APP账号密码登录
*
* @param loginAccountAppDto
* @param response
* @return
* @throws Exception
*/
@PostMapping("/accountLogin")
@Operation(summary = "APP账号密码登录")
public ApiResult<LoginTokenVo> accountLogin(@Valid @RequestBody AppAccountLoginDto loginAccountAppDto, HttpServletRequest request, HttpServletResponse response) {
LoginTokenVo loginTokenVo = appLoginService.accountLogin(loginAccountAppDto);
// 输出token到cookie
addCookie(loginTokenVo.getToken(), request, response);
return ApiResult.success(loginTokenVo);
}
/**
* 获取APP登录用户信息
*
* @return
* @throws Exception
*/
@Login
@PostMapping("/getLoginUserInfo")
@Operation(summary = "获取APP登录用户信息")
public ApiResult<AppLoginVo> getLoginUserInfo() {
AppLoginVo appLoginVo = appLoginService.getLoginUserInfo();
return ApiResult.success(appLoginVo);
}
/**
* APP退出
*
* @return
* @throws Exception
*/
@Login
@PostMapping("/logout")
@Operation(summary = "APP退出")
public ApiResult<Boolean> logout(HttpServletRequest request, HttpServletResponse response) {
appLoginService.logout();
// 从cookie中删除token
CookieUtil.deleteCookie(LoginConstant.APP_COOKIE_TOKEN_NAME, request, response);
return ApiResult.success();
}
/**
* 输出token到cookie
*
* @param token
* @param request
* @param response
*/
private void addCookie(String token, HttpServletRequest request, HttpServletResponse response) {
boolean docRequest = HttpServletRequestUtil.isDocRequest(request);
if (docRequest) {
CookieUtil.addCookie(LoginConstant.APP_COOKIE_TOKEN_NAME, token, request, response);
}
}
}
|
LoginTokenVo loginTokenVo = appLoginService.login(appLoginDto);
// 输出token到cookie
addCookie(loginTokenVo.getToken(), request, response);
return ApiResult.success(loginTokenVo);
| 699
| 66
| 765
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/auth/controller/LoginController.java
|
LoginController
|
login
|
class LoginController {
@Autowired
private LoginService loginService;
/**
* 管理后台登录
*
* @param loginDto
* @param request
* @param response
* @return
* @throws Exception
*/
@PostMapping("/login")
@Operation(summary = "管理后台登录")
public ApiResult<LoginTokenVo> login(@Valid @RequestBody LoginDto loginDto, HttpServletRequest request, HttpServletResponse response) {<FILL_FUNCTION_BODY>}
/**
* 获取管理后台登录用户信息
*
* @return
* @throws Exception
*/
@PostMapping("/getLoginUserInfo")
@Operation(summary = "获取管理后台登录用户信息")
public ApiResult<LoginVo> getLoginUserInfo() {
LoginVo loginVo = loginService.getLoginUserInfo();
return ApiResult.success(loginVo);
}
/**
* 管理后台退出
*
* @return
* @throws Exception
*/
@PostMapping("/logout")
@Operation(summary = "管理后台退出")
public ApiResult<Boolean> logout(HttpServletRequest request, HttpServletResponse response) {
// 删除缓存
loginService.logout();
// 从cookie中删除token
CookieUtil.deleteCookie(LoginConstant.ADMIN_COOKIE_TOKEN_NAME, request, response);
return ApiResult.success();
}
}
|
LoginTokenVo loginTokenVo = loginService.login(loginDto);
// 输出token到cookie
CookieUtil.addCookie(LoginConstant.ADMIN_COOKIE_TOKEN_NAME, loginTokenVo.getToken(), request, response);
return ApiResult.success(loginTokenVo);
| 399
| 84
| 483
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/auth/interceptor/AppLoginInterceptor.java
|
AppLoginInterceptor
|
preHandleMethod
|
class AppLoginInterceptor extends BaseExcludeMethodInterceptor {
@Autowired
private LoginAppProperties loginAppProperties;
@Override
protected boolean preHandleMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {<FILL_FUNCTION_BODY>}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
AppLoginCache.remove();
}
}
|
// 获取token
String token = TokenUtil.getToken();
AppLoginVo appLoginVo = null;
if (StringUtils.isNotBlank(token)) {
// 获取登录用户信息
appLoginVo = AppLoginUtil.getLoginVo(token);
if (appLoginVo != null) {
// 将APP移动端的登录信息保存到当前线程中
AppLoginCache.set(appLoginVo);
}
}
// 判断登录校验策略
LoginInterceptStrategy loginInterceptStrategy = loginAppProperties.getLoginInterceptStrategy();
if (LoginInterceptStrategy.LOGIN == loginInterceptStrategy) {
// 默认都需要登录，此时判断是否有@IgnoreLogin注解，如果有，则跳过，否则，则验证登录
boolean existsIgnoreLoginAnnotation = existsIgnoreLoginAnnotation(handlerMethod);
if (existsIgnoreLoginAnnotation) {
return true;
}
// 是否是排除登录的路径，如果是，则跳过，否则，则验证
boolean isIgnoreLoginPath = isIgnoreLoginPath(request, loginAppProperties.getIgnoreLoginPaths());
if (isIgnoreLoginPath) {
return true;
}
} else {
// 默认都忽略登录，此时判断是否有@Login注解，如果有，则验证登录，否则，则跳过
boolean existsLoginAnnotation = existsLoginAnnotation(handlerMethod);
if (!existsLoginAnnotation) {
// 如果不是要校验的路径，则跳过
boolean isCheckLoginPath = isCheckLoginPath(request, loginAppProperties.getCheckLoginPaths());
if (!isCheckLoginPath) {
return true;
}
}
}
// 登录校验
if (StringUtils.isBlank(token)) {
throw new LoginTokenException("请登录后再操作");
}
// 校验登录用户信息
if (appLoginVo == null) {
throw new LoginTokenException("登录已过期或登录信息不存在，请重新登录");
}
// 校验用户角色
AppUserRole appUserRoleAnnotation = getAppUserRoleAnnotation(handlerMethod);
if (appUserRoleAnnotation != null) {
String[] values = appUserRoleAnnotation.value();
if (ArrayUtils.isNotEmpty(values)) {
Long userRoleId = AppLoginUtil.getUserRoleId();
String userRoleCode = AppLoginUtil.getUserRoleCode();
// 如果方法上的角色ID或角色编码与当前登录用户一致，则放行，否则，跳过
if (ArrayUtils.contains(values, userRoleId) || ArrayUtils.contains(values, userRoleCode)) {
return true;
} else {
throw new AuthException("当前用户没有权限访问");
}
}
}
return true;
| 123
| 725
| 848
|
<methods>public non-sealed void <init>() ,public boolean preHandle(HttpServletRequest, HttpServletResponse, java.lang.Object) throws java.lang.Exception<variables>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/auth/interceptor/CommonLoginInterceptor.java
|
CommonLoginInterceptor
|
preHandleMethod
|
class CommonLoginInterceptor extends BaseExcludeMethodInterceptor {
@Override
protected boolean preHandleMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {<FILL_FUNCTION_BODY>}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
LoginCache.remove();
AppLoginCache.remove();
}
}
|
// 获取token
String token = TokenUtil.getToken();
SystemType systemType = null;
if (StringUtils.isNotBlank(token)) {
systemType = SystemTypeUtil.getSystemTypeByToken(token);
if (SystemType.ADMIN == systemType) {
// 获取管理后台登录用户信息
LoginVo loginVo = LoginUtil.getLoginVo(token);
if (loginVo != null) {
// 将管理后台的登录信息保存到当前线程中
LoginCache.set(loginVo);
}
} else if (SystemType.APP == systemType) {
AppLoginVo loginVo = AppLoginUtil.getLoginVo(token);
if (loginVo != null) {
// 将APP移动端的登录信息保存到当前线程中
AppLoginCache.set(loginVo);
}
}
}
// 如果不存在@Login注解，则跳过
boolean existsLoginAnnotation = existsLoginAnnotation(handlerMethod);
if (!existsLoginAnnotation) {
return true;
}
if (StringUtils.isBlank(token)) {
throw new LoginTokenException("请登录后再操作");
}
if (SystemType.ADMIN == systemType) {
// 获取管理后台登录用户信息
LoginVo loginVo = LoginCache.get();
if (loginVo == null) {
throw new LoginTokenException("登录已过期或登录信息不存在，请重新登录");
}
} else if (SystemType.APP == systemType) {
AppLoginVo loginVo = AppLoginCache.get();
if (loginVo == null) {
throw new LoginTokenException("登录已过期或登录信息不存在，请重新登录");
}
}
return true;
| 112
| 475
| 587
|
<methods>public non-sealed void <init>() ,public boolean preHandle(HttpServletRequest, HttpServletResponse, java.lang.Object) throws java.lang.Exception<variables>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/auth/interceptor/ExcludePathInterceptor.java
|
ExcludePathInterceptor
|
preHandleMethod
|
class ExcludePathInterceptor extends BaseMethodInterceptor {
@Autowired
private BootProperties bootProperties;
@Override
protected boolean preHandleMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {<FILL_FUNCTION_BODY>}
}
|
String servletPath = request.getServletPath();
List<String> excludePaths = bootProperties.getExcludePaths();
if (CollectionUtils.isNotEmpty(excludePaths)) {
for (String excludePath : excludePaths) {
AntPathMatcher antPathMatcher = new AntPathMatcher();
boolean match = antPathMatcher.match(excludePath, servletPath);
if (match) {
request.setAttribute(CommonConstant.REQUEST_PARAM_EXCLUDE_PATH, true);
break;
}
}
}
return true;
| 77
| 150
| 227
|
<methods>public non-sealed void <init>() ,public boolean preHandle(HttpServletRequest, HttpServletResponse, java.lang.Object) throws java.lang.Exception<variables>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/auth/interceptor/LoginInterceptor.java
|
LoginInterceptor
|
preHandleMethod
|
class LoginInterceptor extends BaseExcludeMethodInterceptor {
@Autowired
private LoginAdminProperties loginAdminProperties;
@Override
protected boolean preHandleMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {<FILL_FUNCTION_BODY>}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
LoginCache.remove();
}
}
|
// 如果token
String token = TokenUtil.getToken();
LoginVo loginVo = null;
if (StringUtils.isNotBlank(token)) {
// 获取登录用户信息
loginVo = LoginUtil.getLoginVo(token);
if (loginVo != null) {
// 将管理后台的登录信息保存到当前线程中
LoginCache.set(loginVo);
}
}
// 判断是否存在@IgnoreLogin，存在，则跳过
boolean existsIgnoreLoginAnnotation = existsIgnoreLoginAnnotation(handlerMethod);
if (existsIgnoreLoginAnnotation) {
return true;
}
// 校验登录
if (StringUtils.isBlank(token)) {
throw new LoginTokenException("请登录后再操作");
}
// 校验登录用户信息
if (loginVo == null) {
throw new LoginTokenException("登录已过期或登录信息不存在，请重新登录");
}
// 获取登录信息判断
String roleCode = loginVo.getRoleCode();
boolean loginPermission = loginAdminProperties.isLoginPermission();
boolean admin = loginVo.isAdmin();
if (!admin && loginPermission) {
Permission permission = handlerMethod.getMethodAnnotation(Permission.class);
if (permission != null) {
// 从redis中获取权限列表
List<String> permissions = loginVo.getPermissions();
if (CollectionUtils.isEmpty(permissions)) {
throw new LoginException("当前用户未设置权限");
}
String value = permission.value();
String role = permission.role();
if (!permissions.contains(value)) {
log.error("没有访问权限的登录用户：" + loginVo);
throw new LoginException("没有访问权限");
}
if (StringUtils.isNotBlank(role)) {
if (roleCode.equals(role)) {
log.error("没有访问权限的登录用户：" + loginVo);
throw new LoginException("该角色没有访问权限");
}
}
}
}
return true;
| 121
| 555
| 676
|
<methods>public non-sealed void <init>() ,public boolean preHandle(HttpServletRequest, HttpServletResponse, java.lang.Object) throws java.lang.Exception<variables>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/auth/interceptor/RefreshTokenInterceptor.java
|
RefreshTokenInterceptor
|
preHandleMethod
|
class RefreshTokenInterceptor extends BaseExcludeMethodInterceptor {
@Autowired
private LoginRedisService loginRedisService;
@Autowired
private AppLoginRedisService appLoginRedisService;
@Override
protected boolean preHandleMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {<FILL_FUNCTION_BODY>}
}
|
SystemType systemType = SystemTypeUtil.getSystemTypeByPath(request);
if (SystemType.ADMIN == systemType) {
loginRedisService.refreshToken();
} else if (SystemType.APP == systemType) {
appLoginRedisService.refreshToken();
}
return true;
| 104
| 82
| 186
|
<methods>public non-sealed void <init>() ,public boolean preHandle(HttpServletRequest, HttpServletResponse, java.lang.Object) throws java.lang.Exception<variables>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/auth/interceptor/TokenInterceptor.java
|
TokenInterceptor
|
preHandleMethod
|
class TokenInterceptor extends BaseExcludeMethodInterceptor {
@Override
protected boolean preHandleMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {<FILL_FUNCTION_BODY>}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
TokenCache.remove();
}
}
|
// 获取token
String token = TokenUtil.getToken(request);
if (StringUtils.isBlank(token)) {
return true;
}
// 设置token值到当前线程中，避免重复获取
TokenCache.set(token);
return true;
| 106
| 77
| 183
|
<methods>public non-sealed void <init>() ,public boolean preHandle(HttpServletRequest, HttpServletResponse, java.lang.Object) throws java.lang.Exception<variables>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/auth/service/impl/AppLoginRedisServiceImpl.java
|
AppLoginRedisServiceImpl
|
refreshToken
|
class AppLoginRedisServiceImpl implements AppLoginRedisService {
private static final TimeUnit TOKEN_TIME_UNIT = TimeUnit.DAYS;
@Autowired
private LoginAppProperties loginAppProperties;
@Autowired
private RedisTemplate redisTemplate;
private Integer tokenExpireDays;
@PostConstruct
public void init() {
log.info("loginAppProperties = " + loginAppProperties);
tokenExpireDays = loginAppProperties.getTokenExpireDays();
}
@Override
public String getLoginRedisKey(String token) {
String loginRedisKey = String.format(RedisKey.LOGIN_TOKEN, token);
return loginRedisKey;
}
@Override
public void setLoginVo(String token, AppLoginVo appLoginVo) {
if (appLoginVo == null) {
throw new LoginException("登录用户信息不能为空");
}
if (loginAppProperties.isSingleLogin()) {
// 单点登录，则删除之前该用户的key
deleteLoginInfoByToken(token);
}
// 用户信息
String loginTokenRedisKey = getLoginRedisKey(token);
redisTemplate.opsForValue().set(loginTokenRedisKey, appLoginVo, tokenExpireDays, TOKEN_TIME_UNIT);
}
@Override
public AppLoginVo getLoginVo(String token) {
if (StringUtils.isBlank(token)) {
throw new LoginTokenException("token不能为空");
}
String loginRedisKey = getLoginRedisKey(token);
AppLoginVo appLoginVo = (AppLoginVo) redisTemplate.opsForValue().get(loginRedisKey);
return appLoginVo;
}
@Override
public void deleteLoginVo(String token) {
if (StringUtils.isBlank(token)) {
throw new LoginTokenException("token不能为空");
}
String loginTokenRedisKey = getLoginRedisKey(token);
redisTemplate.delete(loginTokenRedisKey);
}
@Override
public void refreshToken() {<FILL_FUNCTION_BODY>}
@Override
public void deleteLoginInfoByToken(String token) {
log.info("清除用户的所有redis登录信息：" + token);
if (StringUtils.isBlank(token)) {
throw new LoginTokenException("token不能为空");
}
int lastIndexOf = token.lastIndexOf(".");
String userTokenPrefix = token.substring(0, lastIndexOf + 1);
// 删除之前该用户的key
String userTokenRedisPrefix = userTokenPrefix + "*";
String formatRedisTokenPrefix = String.format(RedisKey.LOGIN_TOKEN, userTokenRedisPrefix);
Set keys = redisTemplate.keys(formatRedisTokenPrefix);
if (CollectionUtils.isNotEmpty(keys)) {
redisTemplate.delete(keys);
}
}
}
|
// 刷新token
String token = TokenUtil.getToken();
if (StringUtils.isBlank(token)) {
return;
}
// 刷新key的过期时间
String loginTokenRedisKey = getLoginRedisKey(token);
redisTemplate.expire(loginTokenRedisKey, tokenExpireDays, TOKEN_TIME_UNIT);
| 782
| 101
| 883
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/auth/service/impl/AppLoginServiceImpl.java
|
AppLoginServiceImpl
|
getLoginUserInfo
|
class AppLoginServiceImpl implements AppLoginService {
@Autowired
private UserService userService;
@Autowired
private AppLoginRedisService appLoginRedisService;
@Autowired
private UserRoleService userRoleService;
@Override
public LoginTokenVo login(AppLoginDto dto) {
String code = dto.getCode();
// 获取微信openid
String openid = WxMpApi.getOpenid(code);
// 根据openid获取用户信息
User user = userService.getUserByOpenid(openid);
// 判断是否存在，不存在，则添加
if (user == null) {
// 注册
user = new User();
// 用户昵称：用户+8为随机数字
user.setNickname("用户" + RandomStringUtils.randomNumeric(8));
// 设置微信小程序openid
user.setOpenid(openid);
// 设置注册时间
user.setRegisterTime(new Date());
String requestIp = IpUtil.getRequestIp();
String ipAreaDesc = IpRegionUtil.getIpAreaDesc(requestIp);
// 设置注册IP
user.setRegisterIp(requestIp);
// 设置注册IP区域
user.setRegisterIpArea(ipAreaDesc);
// 设置默认用户为普通角色
user.setUserRoleId(LoginConstant.APP_NORMAL_USER_ROLE);
boolean flag = userService.save(user);
if (!flag) {
throw new BusinessException("注册异常");
}
// 获取用户ID
Long userId = user.getId();
// 根据用户ID获取用户下信息
user = userService.getById(userId);
}
return login(user);
}
@Override
public LoginTokenVo accountLogin(AppAccountLoginDto dto) {
String username = dto.getUsername();
User user = userService.getUserByUsername(username);
// 校验密码
String dbPassword = user.getPassword();
String dbSalt = user.getSalt();
String password = dto.getPassword();
String encryptPassword = PasswordUtil.encrypt(password, dbSalt);
if (!encryptPassword.equals(dbPassword)) {
throw new BusinessException("账号密码错误");
}
return login(user);
}
@Override
public LoginTokenVo login(User user) {
if (user == null) {
throw new LoginException("用户信息不存在");
}
Long userId = user.getId();
// 生成token
String token = TokenUtil.generateAppToken(userId);
// 最后一次登录时间
Date lastLoginTime = new Date();
// 刷新登录信息
refreshLoginInfo(user, token, lastLoginTime);
// 设置登录信息
String requestIp = IpUtil.getRequestIp();
String ipAreaDesc = IpRegionUtil.getIpAreaDesc(requestIp);
// 设置最后登录时间
user.setLastLoginTime(lastLoginTime);
// 设置最后登录IP
user.setLastLoginIp(requestIp);
// 设置最后登录IP区域
user.setLastLoginIpArea(ipAreaDesc);
userService.updateById(user);
// TODO 添加用户登录日志
// 返回token
LoginTokenVo loginTokenVo = new LoginTokenVo();
loginTokenVo.setToken(token);
return loginTokenVo;
}
@Override
public AppLoginVo refreshLoginInfo(User user, String token, Date lastLoginTime) {
Long userId = user.getId();
// 校验用户状态
Boolean status = user.getStatus();
if (status == false) {
throw new LoginException("用户已禁用");
}
// 设置登录用户对象
AppLoginVo appLoginVo = new AppLoginVo();
BeanUtils.copyProperties(user, appLoginVo);
appLoginVo.setUserId(userId);
appLoginVo.setLastLoginTime(lastLoginTime);
// 系统类型 1：管理后台，2：用户端
appLoginVo.setSystemType(SystemType.APP.getCode());
Long userRoleId = user.getUserRoleId();
appLoginVo.setUserRoleId(userRoleId);
if (userRoleId != null) {
UserRole userRole = userRoleService.getById(userRoleId);
if (userRole != null) {
appLoginVo.setUserRoleCode(userRole.getCode());
appLoginVo.setUserRoleName(userRole.getName());
}
}
// 保存登录信息到redis中
appLoginRedisService.setLoginVo(token, appLoginVo);
return appLoginVo;
}
@Override
public AppLoginVo getLoginUserInfo() {<FILL_FUNCTION_BODY>}
@Override
public void logout() {
// 获取token
String token = TokenUtil.getToken();
// 删除缓存
appLoginRedisService.deleteLoginVo(token);
}
}
|
AppLoginVo appLoginVo = AppLoginUtil.getLoginVo();
if (appLoginVo == null) {
throw new LoginException("请先登录");
}
Long userId = appLoginVo.getUserId();
User user = userService.getById(userId);
// 刷新用户登录信息
String token = TokenUtil.getToken();
Date lastLoginTime = appLoginVo.getLastLoginTime();
appLoginVo = refreshLoginInfo(user, token, lastLoginTime);
return appLoginVo;
| 1,356
| 145
| 1,501
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/auth/service/impl/LoginRedisServiceImpl.java
|
LoginRedisServiceImpl
|
deleteLoginVo
|
class LoginRedisServiceImpl implements LoginRedisService {
private static final TimeUnit TOKEN_TIME_UNIT = TimeUnit.MINUTES;
@Autowired
private LoginAdminProperties loginAdminProperties;
@Autowired
private RedisTemplate redisTemplate;
private Integer tokenExpireMinutes;
@PostConstruct
public void init() {
log.info("loginAdminProperties = " + loginAdminProperties);
tokenExpireMinutes = loginAdminProperties.getTokenExpireMinutes();
}
@Override
public String getLoginRedisKey(String token) {
String loginRedisKey = String.format(RedisKey.LOGIN_TOKEN, token);
return loginRedisKey;
}
@Override
public void setLoginVo(String token, LoginVo loginVo) {
if (loginVo == null) {
throw new LoginException("登录用户信息不能为空");
}
if (loginAdminProperties.isSingleLogin()) {
// 单点登录，则删除之前该用户的key
deleteLoginInfoByToken(token);
}
// 用户信息
String loginTokenRedisKey = getLoginRedisKey(token);
redisTemplate.opsForValue().set(loginTokenRedisKey, loginVo, tokenExpireMinutes, TOKEN_TIME_UNIT);
}
@Override
public LoginVo getLoginVo(String token) {
if (StringUtils.isBlank(token)) {
throw new LoginTokenException("token不能为空");
}
String loginRedisKey = getLoginRedisKey(token);
LoginVo loginVo = (LoginVo) redisTemplate.opsForValue().get(loginRedisKey);
return loginVo;
}
@Override
public void deleteLoginVo(String token) {<FILL_FUNCTION_BODY>}
@Override
public void refreshToken() {
// 刷新token
String token = TokenUtil.getToken();
if (StringUtils.isBlank(token)) {
return;
}
// 刷新key的过期时间
String loginTokenRedisKey = getLoginRedisKey(token);
redisTemplate.expire(loginTokenRedisKey, tokenExpireMinutes, TOKEN_TIME_UNIT);
}
@Override
public void deleteLoginInfoByToken(String token) {
log.info("清除用户的所有redis登录信息：" + token);
if (StringUtils.isBlank(token)) {
throw new LoginTokenException("token不能为空");
}
int lastIndexOf = token.lastIndexOf(".");
String userTokenPrefix = token.substring(0, lastIndexOf + 1);
// 删除之前该用户的key
String userTokenRedisPrefix = userTokenPrefix + "*";
String formatRedisTokenPrefix = String.format(RedisKey.LOGIN_TOKEN, userTokenRedisPrefix);
Set keys = redisTemplate.keys(formatRedisTokenPrefix);
if (CollectionUtils.isNotEmpty(keys)) {
redisTemplate.delete(keys);
}
}
}
|
if (StringUtils.isBlank(token)) {
throw new LoginTokenException("token不能为空");
}
String loginTokenRedisKey = getLoginRedisKey(token);
redisTemplate.delete(loginTokenRedisKey);
| 809
| 64
| 873
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/auth/service/impl/LoginServiceImpl.java
|
LoginServiceImpl
|
refreshLoginInfo
|
class LoginServiceImpl implements LoginService {
@Autowired
private SysUserMapper sysUserMapper;
@Autowired
private SysRoleMapper sysRoleMapper;
@Autowired
private SysMenuMapper sysMenuMapper;
@Autowired
private LoginRedisService loginRedisService;
@Override
public LoginTokenVo login(LoginDto dto) {
String username = dto.getUsername();
SysUser sysUser = sysUserMapper.getSysUserByUsername(username);
if (sysUser == null) {
throw new BusinessException("用户信息不存在");
}
// 用户ID
Long userId = sysUser.getId();
// 校验密码
String dbPassword = sysUser.getPassword();
String dbSalt = sysUser.getSalt();
String password = dto.getPassword();
String encryptPassword = PasswordUtil.encrypt(password, dbSalt);
if (!encryptPassword.equals(dbPassword)) {
throw new BusinessException("账号密码错误");
}
// 生成token
String token = TokenUtil.generateAdminToken(userId);
// 刷新登录信息
refreshLoginInfo(sysUser, token, new Date());
// 返回token
LoginTokenVo loginTokenVo = new LoginTokenVo();
loginTokenVo.setToken(token);
return loginTokenVo;
}
@Override
public LoginVo refreshLoginInfo(SysUser sysUser, String token, Date loginTime) {<FILL_FUNCTION_BODY>}
@Override
public LoginVo getLoginUserInfo() {
LoginVo loginVo = LoginUtil.getLoginVo();
if (loginVo == null) {
throw new LoginException("请先登录");
}
// 根据用户ID获取用户信息
Long userId = loginVo.getUserId();
// 获取用户登录时间
Date loginTime = loginVo.getLoginTime();
SysUser sysUser = sysUserMapper.selectById(userId);
if (sysUser == null) {
throw new BusinessException("用户信息不存在");
}
// 刷新登录信息
String token = TokenUtil.getToken();
loginVo = refreshLoginInfo(sysUser, token, loginTime);
return loginVo;
}
@Override
public void logout() {
try {
// 获取token
String token = TokenUtil.getToken();
// 删除缓存
loginRedisService.deleteLoginVo(token);
} catch (Exception e) {
e.printStackTrace();
}
}
}
|
// 用户ID
Long userId = sysUser.getId();
// 校验用户状态
Boolean status = sysUser.getStatus();
if (status == false) {
throw new BusinessException("用户已禁用");
}
// 查询用户角色
Long roleId = sysUser.getRoleId();
SysRole sysRole = sysRoleMapper.selectById(roleId);
if (sysRole == null) {
throw new BusinessException("该用户不存在可用的角色");
}
// 设置登录用户对象
LoginVo loginVo = new LoginVo();
BeanUtils.copyProperties(sysUser, loginVo);
loginVo.setUserId(userId);
loginVo.setLoginTime(loginTime);
loginVo.setAdmin(sysUser.getIsAdmin());
loginVo.setRoleCode(sysRole.getCode());
loginVo.setRoleName(sysRole.getName());
// 系统类型 1：管理后台，2：用户端
loginVo.setSystemType(SystemType.ADMIN.getCode());
// 获取登录用户的权限编码
List<String> permissions = sysMenuMapper.getPermissionCodesByUserId(userId);
loginVo.setPermissions(permissions);
// 保存登录信息到redis中
loginRedisService.setLoginVo(token, loginVo);
return loginVo;
| 690
| 367
| 1,057
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/auth/util/AppLoginUtil.java
|
AppLoginUtil
|
getUserId
|
class AppLoginUtil {
private static AppLoginRedisService appLoginRedisService;
public AppLoginUtil(AppLoginRedisService appLoginRedisService) {
AppLoginUtil.appLoginRedisService = appLoginRedisService;
}
/**
* 根据token从redis中获取登录用户信息
*
* @param token
* @return
* @
*/
public static AppLoginVo getLoginVo(String token) {
if (StringUtils.isBlank(token)) {
return null;
}
AppLoginVo appLoginVo = appLoginRedisService.getLoginVo(token);
return appLoginVo;
}
/**
* 从当前线程中获取登录用户信息
*
* @return
*/
public static AppLoginVo getLoginVo() {
return AppLoginCache.get();
}
/**
* 获取登录用户ID
*
* @return
*/
public static Long getUserId() {<FILL_FUNCTION_BODY>}
/**
* 获取登录用户ID字符串
*
* @return
* @
*/
public static String getUserIdString() {
Long userId = getUserId();
if (userId == null) {
return null;
}
return userId.toString();
}
/**
* 获取登录用户名
*
* @return
*/
public static String getUsername() {
AppLoginVo appLoginVo = getLoginVo();
if (appLoginVo != null) {
return appLoginVo.getUsername();
}
return null;
}
/**
* 获取用户角色ID
*
* @return
*/
public static Long getUserRoleId() {
AppLoginVo appLoginVo = getLoginVo();
if (appLoginVo != null) {
return appLoginVo.getUserRoleId();
}
return null;
}
/**
* 获取用户角色编码
*
* @return
*/
public static String getUserRoleCode() {
AppLoginVo appLoginVo = getLoginVo();
if (appLoginVo != null) {
return appLoginVo.getUserRoleCode();
}
return null;
}
}
|
AppLoginVo appLoginVo = getLoginVo();
if (appLoginVo != null) {
return appLoginVo.getUserId();
}
return null;
| 623
| 52
| 675
|
<no_super_class>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.