Redis测试-java代码

发表于 2018-06-04 分类于 Redis 本文字数： 636 阅读时长 ≈ 2 分钟

pom.xml

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>

简单测试

public static void main(String[] args) {
    Jedis jedis = new Jedis("192.168.1.213");
    jedis.set("foo", "bar");
    String value = jedis.get("foo");
    System.out.println(value);
}

如果用这种方法连集群，会看到如下的错误

1	Exception in thread "main" redis.clients.jedis.exceptions.JedisMovedDataException: MOVED 12182 192.168.1.214:6382

Redis集群测试

public static void main(String[] args) {
    Set<HostAndPort> jedisClusterNodes = new HashSet<HostAndPort>();
    // Jedis集群将尝试自动发现集群节点
    jedisClusterNodes.add(new HostAndPort("192.168.1.214", 6379));
    // jedisClusterNodes.add(new HostAndPort("192.168.1.214", 6380));
    // jedisClusterNodes.add(new HostAndPort("192.168.1.214", 6381));
    JedisCluster jc = new JedisCluster(jedisClusterNodes);
    jc.set("foo", "bar");
    jc.set("foo1", "bar1");
    jc.set("foo2", "bar2");
    jc.set("foo3", "bar3");
    jc.set("foo4", "bar4");
    jc.set("foo5", "bar5");
    jc.set("foo6", "bar6");

    System.out.println(jc.get("foo"));
    System.out.println(jc.get("foo1"));
    System.out.println(jc.get("foo2"));
    System.out.println(jc.get("foo3"));
    System.out.println(jc.get("foo4"));
    System.out.println(jc.get("foo5"));
    System.out.println(jc.get("foo6"));

    System.out.println("===================");

    Map<String, JedisPool> map = jc.getClusterNodes();
    for (Map.Entry<String, JedisPool> e : map.entrySet()) {
        System.out.println(e.getKey());
        System.out.println("===================");
    }

}

运行时报错：

Exception in thread "main" redis.clients.jedis.exceptions.JedisConnectionException: Could not get a resource from the pool
	at redis.clients.util.Pool.getResource(Pool.java:53)
	at redis.clients.jedis.JedisPool.getResource(JedisPool.java:226)
	at redis.clients.jedis.JedisSlotBasedConnectionHandler.getConnectionFromSlot(JedisSlotBasedConnectionHandler.java:66)
...
...

因为在之前创建创建集群时使用的IP是127.0.0.1，当返回(error) MOVED 10439 127.0.0.1:6381时，系统尝试连接本地的端口，然后连不上失败了

修改Redis配置文件，绑定到正确的IP上，然后重新创建集群指定具体的IP地址：

1	./redis-trib.rb create --replicas 1 192.168.1.214:6379 192.168.1.214:6381 192.168.1.214:6382 192.168.1.214:6383 192.168.1.214:6384 192.168.1.214:6385

#杀掉redis进程
ps -ef | grep redis | awk '{print $2}' | xargs kill

#删除
rm -f /data/redis/d63*/dump.rdb
rm -f /data/redis/d63*/nodes.conf

#批量替换
sed -i 's/192.168.1.214/0.0.0.0/' */redis.conf

Jedis客户端分片测试

分片使用一种称为“一致哈希”的技术，并根据一些散列算法（md5和murmur，后者不太标准，但速度更快）在一组redis服务器上同等地分配key值。这样的节点被称为“分片”。优点是每个分片只会占总内存的 1/n（对于n是分片数量）。

先配置三个独立的redis服务

直连接方式

public static void main(String[] args) {
    List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
    JedisShardInfo si = new JedisShardInfo("192.168.1.213", 6380);
    shards.add(si);
    si = new JedisShardInfo("192.168.1.213", 6381);
    shards.add(si);
    si = new JedisShardInfo("192.168.1.213", 6382);
    shards.add(si);

    // 直接连接
    ShardedJedis jedis = new ShardedJedis(shards);
    jedis.set("a", "foo");
    jedis.set("a1", "foo1");
    jedis.set("a2", "foo2");
    jedis.set("a3", "foo3");
    jedis.set("a4", "foo4");

    System.out.println(jedis.get("a"));
    System.out.println(jedis.get("a1"));
    System.out.println(jedis.get("a2"));
    System.out.println(jedis.get("a3"));
    System.out.println(jedis.get("a4"));

    ShardInfo<?> sinfo = jedis.getShardInfo("a");
    System.out.println(sinfo);

    jedis.disconnect();
    jedis.close();
}

连接池方式

public static void main(String[] args) {
    List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
    JedisShardInfo si = new JedisShardInfo("192.168.1.213", 6380);
    shards.add(si);
    si = new JedisShardInfo("192.168.1.213", 6381);
    shards.add(si);
    si = new JedisShardInfo("192.168.1.213", 6382);
    shards.add(si);

    // 池连接
    JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
    ShardedJedisPool pool = new ShardedJedisPool(jedisPoolConfig, shards);

    try (ShardedJedis jedis = pool.getResource()) {
        jedis.set("x", "foo");
        jedis.set("x1", "foo1");
        jedis.set("x2", "foo2");
    }

    try (ShardedJedis jedis2 = pool.getResource()) {
        jedis2.set("y", "bar");
        jedis2.set("y1", "bar1");
        jedis2.set("y2", "bar2");
    }

    try (ShardedJedis jedis = pool.getResource()) {
        System.out.println(jedis.get("x"));
        System.out.println(jedis.get("x1"));
        System.out.println(jedis.get("x2"));
    }

    try (ShardedJedis jedis2 = pool.getResource()) {
        System.out.println(jedis2.get("y"));
        System.out.println(jedis2.get("y1"));
        System.out.println(jedis2.get("y2"));
    }

    pool.close();
}

Spring XML、注解、Java类配置

发表于 2018-06-04 分类于 Spring 本文字数： 745 阅读时长 ≈ 3 分钟

配置Spring一般包括3种方式

基于XML的配置文件
基于注解的配置
基于Java的配置

基于XML的配置

这个很常见，比如：

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
      <property name = "message" value = "Hello World!"/>
   </bean>

</beans>

这种配置可以通过容器来加载，也可以通过FileSystemXmlApplicationContext、ClassPathXmlApplicationContext 等来加载，如：

1
2
3

AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        
context.getBean("helloWorld");

使用注解

配置了<context：annotation-config />开启注解

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context = "http://www.springframework.org/schema/context"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>
   <!-- bean definitions go here -->

</beans>

注解	说明
@Required	用于bean属性的setter方法
@Autowired	可以应用于bean属性setter方法、非setter方法、构造函数和属性
@Qualifier	@Qualifier注解和@Autowired一起可以通过指定连接哪个bean来消除混淆。
JSR-250 Annotations	Spring支持基于JSR-250的注解，包括@Resource、@PostConstruct和@PreDestroy注解。

基于java的方式

@Configuration & @Bean

使用@Configuration注解一个类表明该类可以被Spring IoC容器用作bean定义的来源。该@Bean注解告诉Spring与@Bean注释的方法将返回应注册为Spring应用程序上下文的bean的对象。最简单的@Configuration类如下：

package com.tutorialspoint;
import org.springframework.context.annotation.*;

@Configuration
public class HelloWorldConfig {
   @Bean 
   public HelloWorld helloWorld(){
      return new HelloWorld();
   }
}

以上代码将等同于以下XML配置 -

1
2
3

<beans>
   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" />
</beans>

这里，方法名用@Bean作为bean ID进行注释，并创建并返回实际的bean。你的配置类可以拥有多个@Bean的声明。一旦你的配置类被定义，你可以使用AnnotationConfigApplicationContext加载并提供给Spring容器，如下所示：

public static void main(String[] args) {
   ApplicationContext ctx = new AnnotationConfigApplicationContext(HelloWorldConfig.class);
   
   HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
   helloWorld.setMessage("Hello World!");
   helloWorld.getMessage();
}

可以按如下方式加载各种配置类：

public static void main(String[] args) {
   AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();

   ctx.register(AppConfig.class, OtherConfig.class);
   ctx.register(AdditionalConfig.class);
   ctx.refresh();

   MyService myService = ctx.getBean(MyService.class);
   myService.doStuff();
}

@Import

@Import注解允许从另一个配置类加载@Bean定义
如配置类A

@Configuration
public class ConfigA {
   @Bean
   public A a() {
      return new A(); 
   }
}

可以在另一个Bean声明中导入上面的Bean声明，如下所示

@Configuration
@Import(ConfigA.class)
public class ConfigB {
   @Bean
   public B a() {
      return new A(); 
   }
}

现在，不需要在实例化上下文时指定ConfigA.class和ConfigB.class，只需要提供ConfigB，如下所示

public static void main(String[] args) {
   ApplicationContext ctx = new AnnotationConfigApplicationContext(ConfigB.class);
   
   // now both beans A and B will be available...
   A a = ctx.getBean(A.class);
   B b = ctx.getBean(B.class);
}

生命周期回调

@Bean注解支持指定任意初始化和销毁回调方法，就像Spring XML的bean元素的init-method和destroy-method属性一样

public class Foo {
   public void init() {
      // initialization logic
   }
   public void cleanup() {
      // destruction logic
   }
}
@Configuration
public class AppConfig {
   @Bean(initMethod = "init", destroyMethod = "cleanup" )
   public Foo foo() {
      return new Foo();
   }
}

指定Bean范围

默认范围是单例，但您可以使用@Scope注释覆盖它，如下所示

@Configuration
public class AppConfig {
   @Bean
   @Scope("prototype")
   public Foo foo() {
      return new Foo();
   }
}

Spring中的事件处理

发表于 2018-06-04 分类于 Spring 本文字数： 722 阅读时长 ≈ 3 分钟

Spring的核心是ApplicationContext，它管理bean的整个生命周期。ApplicationContext在加载Bean时发布某些类型的事件。例如，ContextStartedEvent在上下文启动时发布，而ContextStoppedEvent在上下文停止时发布。

ApplicationContext中的事件处理通过ApplicationEvent类和ApplicationListener接口提供。如果一个bean实现了ApplicationListener，那么每当一个ApplicationEvent被发布到ApplicationContext时，该bean就会被通知。

Spring提供了以下标准事件

事件	描述
ContextRefreshedEvent	此事件在ApplicationContext初始化或刷新时发布。这也可以使用ConfigurableApplicationContext接口上的refresh（）方法引发。
ContextStartedEvent	使用ConfigurableApplicationContext接口上的start（）方法启动ApplicationContext时，会发布此事件。
ContextStoppedEvent	使用ConfigurableApplicationContext接口上的stop（）方法停止ApplicationContext时发布此事件。
ContextClosedEvent	使用ConfigurableApplicationContext接口上的close（）方法关闭ApplicationContext时发布此事件。一个关闭的上下文达到其生命的尽头，它不能被刷新或重新启动。
RequestHandledEvent	这是一个特定于web的事件，它告诉所有bean已经提供HTTP请求。

Spring的事件处理是单线程的，一个事件被发布，直到所有的接收者都处理完这个消息之前，进程会被阻塞，流程将不会继续。因此，如果要使用事件处理，应在设计应用程序时小心谨慎。

听上下文事件

要监听上下文事件，bean应该实现只有一个方法onApplicationEvent（）的ApplicationListener接口。

HelloWorld.java文件

package com.tutorialspoint;

public class HelloWorld {
   private String message;

   public void setMessage(String message){
      this.message  = message;
   }
   public void getMessage(){
      System.out.println("Your Message : " + message);
   }
}

CStartEventHandler.java文件

package com.tutorialspoint;

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextStartedEvent;

public class CStartEventHandler 
   implements ApplicationListener<ContextStartedEvent>{

   public void onApplicationEvent(ContextStartedEvent event) {
      System.out.println("ContextStartedEvent Received");
   }
}

CStopEventHandler.java文件

package com.tutorialspoint;

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextStoppedEvent;

public class CStopEventHandler 
   implements ApplicationListener<ContextStoppedEvent>{

   public void onApplicationEvent(ContextStoppedEvent event) {
      System.out.println("ContextStoppedEvent Received");
   }
}

MainApp.java文件

package com.tutorialspoint;

import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ConfigurableApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");

      // Let us raise a start event.
      context.start();
	  
      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();

      // Let us raise a stop event.
      context.stop();
   }
}

配置文件Beans.xml

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
      <property name = "message" value = "Hello World!"/>
   </bean>

   <bean id = "cStartEventHandler" class = "com.tutorialspoint.CStartEventHandler"/>
   <bean id = "cStopEventHandler" class = "com.tutorialspoint.CStopEventHandler"/>

</beans>

程序运行结果

1
2
3

ContextStartedEvent Received
Your Message : Hello World!
ContextStoppedEvent Received

自定义事件

CustomEvent.java文件

package com.tutorialspoint;

import org.springframework.context.ApplicationEvent;

public class CustomEvent extends ApplicationEvent{
   public CustomEvent(Object source) {
      super(source);
   }
   public String toString(){
      return "My Custom Event";
   }
}

CustomEventPublisher.java文件

package com.tutorialspoint;

import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;

public class CustomEventPublisher implements ApplicationEventPublisherAware {
   private ApplicationEventPublisher publisher;
   
   public void setApplicationEventPublisher (ApplicationEventPublisher publisher) {
      this.publisher = publisher;
   }
   public void publish() {
      CustomEvent ce = new CustomEvent(this);
      publisher.publishEvent(ce);
   }
}

CustomEventHandler.java文件

package com.tutorialspoint;

import org.springframework.context.ApplicationListener;

public class CustomEventHandler implements ApplicationListener<CustomEvent> {
   public void onApplicationEvent(CustomEvent event) {
      System.out.println(event.toString());
   }
}

MainApp.java文件

package com.tutorialspoint;

import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ConfigurableApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");
	  
      CustomEventPublisher cvp = 
         (CustomEventPublisher) context.getBean("customEventPublisher");
      
      cvp.publish();  
      cvp.publish();
   }
}

配置文件Beans.xml

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "customEventHandler" class = "com.tutorialspoint.CustomEventHandler"/>
   <bean id = "customEventPublisher" class = "com.tutorialspoint.CustomEventPublisher"/>

</beans>

运行结果

1 2	My Custom Event My Custom Event

Spring介绍

发表于 2018-06-04 分类于 Spring 本文字数： 3.1k 阅读时长 ≈ 11 分钟

从这个地方随手翻译过来的
https://www.tutorialspoint.com/spring/index.htm

概述

Spring是企业Java最流行的应用程序开发框架。全球数以百万计的开发人员使用Spring Framework创建高性能，易于测试和可重用的代码。

Spring框架是一个开源的Java平台。它最初由Rod Johnson编写，并于2003年6月首次在Apache 2.0许可下发布。

Spring框架的核心功能可以用于开发任何Java应用程序，但是在Java EE平台之上还可以扩展构建Web应用程序。Spring框架的目标是通过启用基于POJO的编程模型来使J2EE开发更易于使用，并促进良好的编程实践。

依赖注入（DI）

Spring最认常用技术是控制反转的依赖注入（DI）。该控制反转（IOC）是一个笼统的概念，它可以在许多不同的方式来表达。依赖注入仅仅是控制反转的一个具体例子。

面向切面编程（AOP）

Spring的关键组件之一是面向切面编程（AOP）框架。跨越应用程序多个点的功能称为横切关注点，这些横切关注点在概念上与应用程序的业务逻辑分离。有各种常见的很好的例子，包括日志记录，声明式事务，安全性，缓存等等。

框架

Spring框架提供了大约20个模块，可以根据应用需求使用。

核心容器

核心容器由Core，Beans，Context和Expression Language模块组成

Core 提供了框架的基本部分，包括IOC和依赖注入特征。
Beans 提供的BeanFactory，是工厂模式的一个复杂实现。
Context 上下文模块构建在Core和Beans模块提供的基础之上，它是访问定义和配置的任何对象的媒介。ApplicationContext接口是上下文模块的焦点。
Expression Language SpEL模块提供了一种强大的表达式语言，用于在运行时查询和操作对象图。

数据访问/集成

数据访问/集成层由JDBC，ORM，OXM，JMS和事务模块组成

JDBC模块提供了JDBC抽象层，消除了对冗长的JDBC相关编码的需要。
ORM模块为流行的对象-关系映射api提供集成层，包括JPA、JDO、Hibernate和iBatis。
OXM模块提供了一个抽象层，支持JAXB、Castor、XMLBeans、JiBX和XStream的对象/XML映射实现。
Java消息传递服务JMS模块包含用于生成和使用消息的功能。
事务模块支持实现特殊接口和所有pojo的类的编程和声明式事务管理。

WEB

Web层由Web，Web-MVC，Web-Socket和Web-Portlet模块组成

Web模块提供面向Web的基本集成特性，如多部分文件上传功能，以及使用servlet侦听器和面向Web的应用程序上下文初始化IoC容器。
Web-MVC模块包含用于web应用程序的Spring的模型-视图-控制器(MVC)实现。
Web-Socket模块支持web应用程序中的客户端和服务器之间的基于websocket的双向通信。
Web-Portlet模块提供了将在portlet环境中使用的MVC实现，并镜像了web servlet模块的功能。

杂项

重要模块像AOP，Aspects（切面），仪表，消息和测试模块等
…
…

Bean定义

构成应用程序主干和由Spring IoC容器管理的对象称为bean。bean是由Spring IoC容器实例化、组装和管理的对象。这些bean是用你提供给容器的配置元数据创建的。例如，XML 定义的形式

配置一个bean容器需要知道如下信息：

如何创建一个bean
Bean的生命周期细节
Bean的依赖关系

属性	说明
class	该属性是强制性的，指定了用于创建bean的类。
name	该属性唯一的指定了bean标识符。在基于XML的配置元数据中，使用id （and/or）name属性来指定bean标识符。
scope	指定了从特定的bean定义创建的对象的范围
constructor-arg	构造参数，用于注入依赖关系
properties	属性，用于注入依赖关系
autowiring mode	自动装配模式，用于注入依赖关系
lazy-initialization mode	延时加载,告诉IoC容器在第一次请求时创建一个bean实例，而不是在启动时
initialization method	初始化方法，在bean的所有必要属性设置之后立即调用的回调方面
destruction method	销毁方法，在bean的容器被销毁时要调用的回调函数

Spring 配置

配置Spring一般包括3中方式

基于XML的配置文件
基于注解的配置
基于Java的配置

基于XML的配置文件示例：

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <!-- A simple bean definition -->
   <bean id = "..." class = "...">
      <!-- collaborators and configuration for this bean go here -->
   </bean>

   <!-- A bean definition with lazy init set on -->
   <bean id = "..." class = "..." lazy-init = "true">
      <!-- collaborators and configuration for this bean go here -->
   </bean>

   <!-- A bean definition with initialization method -->
   <bean id = "..." class = "..." init-method = "...">
      <!-- collaborators and configuration for this bean go here -->
   </bean>

   <!-- A bean definition with destruction method -->
   <bean id = "..." class = "..." destroy-method = "...">
      <!-- collaborators and configuration for this bean go here -->
   </bean>

   <!-- more bean definitions go here -->
   
</beans>

Bean的范围

定义一个时，你可以选择为该bean声明一个范围。例如，为了强制Spring在每次需要时产生一个新的bean实例，你应该声明bean的scope属性是prototype。同样，如果你希望Spring在每次需要时都返回相同的bean实例，你应该声明bean的scope属性为singleton。

Spring框架支持以下五个范围，其中三个仅在您使用Web感知的ApplicationContext时才可用。

范围	说明
singleton	单实例，每次都使用同一个bean（默认值），对象创建好之后会被缓存，
prototype	多实例，每次都返回新的实例
request	在一次HTTP请求中使用相同实例。只有在Web感知的Spring ApplicationContext的上下文中才有效。
session	在一个HTTP会话中使用相同实例。只有在Web感知的Spring ApplicationContext的上下文中才有效。
global-session	在一个全局HTTP会话中使用相同实例。只有在Web感知的Spring ApplicationContext的上下文中才有效。

Bean的生命周期

初始化回调

public class ExampleBean implements InitializingBean {
   public void afterPropertiesSet() {
      // do some initialization work
   }
}

对于基于XML的配置元数据，可以使用init-method属性来指定具有void无参数签名的方法的名称。例如：

<bean id = "exampleBean" class = "examples.ExampleBean" init-method = "init"/>

public class ExampleBean {
   public void init() {
      // do some initialization work
   }
}

销毁回调

public class ExampleBean implements DisposableBean {
   public void destroy() {
      // do some destruction work
   }
}

对于基于XML的配置元数据，可以使用destroy-method属性来指定具有void无参数签名的方法的名称。例如：

<bean id = "exampleBean" class = "examples.ExampleBean" destroy-method = "destroy"/>

public class ExampleBean {
   public void destroy() {
      // do some destruction work
   }
}

默认初始化和销毁方法

如果你的bean有太多具有相同名称的初始化和/或销毁方法，则不需要在每个单独的bean上声明init-method和destroy-method。这种情况可以使用元素上的default-init-method和default-destroy-method属性来配置，如下所示：

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"
   default-init-method = "init" 
   default-destroy-method = "destroy">

   <bean id = "..." class = "...">
      <!-- collaborators and configuration for this bean go here -->
   </bean>
   
</beans>

Bean Post Processors

BeanPostProcessor接口定义了回调方法，你可以实现这些方法来提供您自己的实例化逻辑、依赖解析逻辑等。还可以在Spring容器完成实例化、配置和初始化bean之后，通过插入一个或多个BeanPostProcessor实现来实现一些自定义逻辑。
可以配置多个BeanPostProcessor接口，并且您可以通过设置order属性来控制这些BeanPostProcessor接口执行的顺序。

ApplicationContext自动检测由BeanPostProcessor接口实现定义的任何bean，并将这些bean注册为postprocessor，然后容器在创建bean时相应地调用这些bean。

HelloWorld.java文件的内容：

package com.tutorialspoint;

public class HelloWorld {
   private String message;

   public void setMessage(String message){
      this.message  = message;
   }
   public void getMessage(){
      System.out.println("Your Message : " + message);
   }
   public void init(){
      System.out.println("Bean is going through init.");
   }
   public void destroy(){
      System.out.println("Bean will destroy now.");
   }
}

InitHelloWorld.java文件

package com.tutorialspoint;

import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.BeansException;

public class InitHelloWorld implements BeanPostProcessor {
   public Object postProcessBeforeInitialization(Object bean, String beanName) 
      throws BeansException {
      
      System.out.println("BeforeInitialization : " + beanName);
      return bean;  // you can return any other object as well
   }
   public Object postProcessAfterInitialization(Object bean, String beanName) 
      throws BeansException {
      
      System.out.println("AfterInitialization : " + beanName);
      return bean;  // you can return any other object as well
   }
}

Beans.xml 文件

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld"
      init-method = "init" destroy-method = "destroy">
      <property name = "message" value = "Hello World!"/>
   </bean>

   <bean class = "com.tutorialspoint.InitHelloWorld" />

</beans>

MainApp.java文件

package com.tutorialspoint;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");

      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();
      context.registerShutdownHook();
   }
}

执行结果：

BeforeInitialization : helloWorld
Bean is going through init.
AfterInitialization : helloWorld
Your Message : Hello World!
Bean will destroy now.

Bean定义继承

bean定义可以包含许多配置信息，包括构造函数参数、属性值和容器特定的信息，如初始化方法、静态工厂方法名称等。

子bean定义从父定义继承配置数据。子定义可以覆盖一些值，或者根据需要添加其他值。
Spring Bean定义继承与Java类继承没有关系，但是继承概念是相同的。可以将父bean定义定义定义为模板，其他子bean可以从父bean继承所需的配置。

当使用基于xml的配置元数据时，您通过使用父属性指定子bean定义，指定父bean作为该属性的值。

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
      <property name = "message1" value = "Hello World!"/>
      <property name = "message2" value = "Hello Second World!"/>
   </bean>

   <bean id =" helloIndia" class = "com.tutorialspoint.HelloIndia" parent = "helloWorld">
      <property name = "message1" value = "Hello India!"/>
      <property name = "message3" value = "Namaste India!"/>
   </bean>
</beans>

定义模板

定义Bean定义模板时，不应指定类属性

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "beanTeamplate" abstract = "true">
      <property name = "message1" value = "Hello World!"/>
      <property name = "message2" value = "Hello Second World!"/>
      <property name = "message3" value = "Namaste India!"/>
   </bean>

   <bean id = "helloIndia" class = "com.tutorialspoint.HelloIndia" parent = "beanTeamplate">
      <property name = "message1" value = "Hello India!"/>
      <property name = "message3" value = "Namaste India!"/>
   </bean>
   
</beans>

父bean不能自行实例化，因为它是不完整的，并且它也明确标记为抽象。当定义像这样抽象时，它只能用作纯模板bean定义，作为子定义的父定义。

依赖注入

依赖注入主要包括基于构造函数的依赖注入和基于Setter的依赖注入

基于setter的注入但使用内部bean的配置

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <!-- Definition for textEditor bean using inner bean -->
   <bean id = "textEditor" class = "com.tutorialspoint.TextEditor">
      <property name = "spellChecker">
         <bean id = "spellChecker" class = "com.tutorialspoint.SpellChecker"/>
      </property>
   </bean>

</beans>

注入集合

包括list、set、map、props

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <!-- Definition for javaCollection -->
   <bean id = "javaCollection" class = "com.tutorialspoint.JavaCollection">
      
      <!-- results in a setAddressList(java.util.List) call -->
      <property name = "addressList">
         <list>
            <value>INDIA</value>
            <value>Pakistan</value>
            <value>USA</value>
            <value>USA</value>
         </list>
      </property>

      <!-- results in a setAddressSet(java.util.Set) call -->
      <property name = "addressSet">
         <set>
            <value>INDIA</value>
            <value>Pakistan</value>
            <value>USA</value>
            <value>USA</value>
         </set>
      </property>

      <!-- results in a setAddressMap(java.util.Map) call -->
      <property name = "addressMap">
         <map>
            <entry key = "1" value = "INDIA"/>
            <entry key = "2" value = "Pakistan"/>
            <entry key = "3" value = "USA"/>
            <entry key = "4" value = "USA"/>
         </map>
      </property>
      
      <!-- results in a setAddressProp(java.util.Properties) call -->
      <property name = "addressProp">
         <props>
            <prop key = "one">INDIA</prop>
            <prop key = "one">INDIA</prop>
            <prop key = "two">Pakistan</prop>
            <prop key = "three">USA</prop>
            <prop key = "four">USA</prop>
         </props>
      </property>
   </bean>

</beans>

将bean引用注入为集合元素中，使引用和值混合在一起

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <!-- Bean Definition to handle references and values -->
   <bean id = "..." class = "...">

      <!-- Passing bean reference  for java.util.List -->
      <property name = "addressList">
         <list>
            <ref bean = "address1"/>
            <ref bean = "address2"/>
            <value>Pakistan</value>
         </list>
      </property>
      
      <!-- Passing bean reference  for java.util.Set -->
      <property name = "addressSet">
         <set>
            <ref bean = "address1"/>
            <ref bean = "address2"/>
            <value>Pakistan</value>
         </set>
      </property>
      
      <!-- Passing bean reference  for java.util.Map -->
      <property name = "addressMap">
         <map>
            <entry key = "one" value = "INDIA"/>
            <entry key = "two" value-ref = "address1"/>
            <entry key = "three" value-ref = "address2"/>
         </map>
      </property>
   </bean>

</beans>

要使用上面的bean定义，你需要定义你的setter方法，以便它们也能够处理引用。

注入空和空字符串值

空字符串作为值:

1
2
3

<bean id = "..." class = "exampleBean">
   <property name = "email" value = ""/>
</bean>

传递一个NULL值

1
2
3

<bean id = "..." class = "exampleBean">
   <property name = "email"><null/></property>
</bean>

等同于：exampleBean.setEmail(null)

Spring Data Redis

发表于 2018-05-31 分类于 Redis 本文字数： 515 阅读时长 ≈ 2 分钟

配置

   <!-- redis配置 -->
<!-- jedis pool配置 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
	<property name="maxTotal" value="${redis.maxTotal}" />
	<property name="maxIdle" value="${redis.maxIdle}" />
	<property name="maxWaitMillis" value="${redis.maxWaitMillis}" />
	<property name="testOnBorrow" value="${redis.testOnBorrow}" />
</bean>

<!-- Jedis ConnectionFactory -->
<bean id='jedisConnectionFactory'
	class='org.springframework.data.redis.connection.jedis.JedisConnectionFactory'>
	<property name="usePool" value="true"></property>
	<property name="hostName" value="${redis.host}" />
	<property name="port" value="${redis.port}" />
	<property name="password" value="${redis.pass}" />
	<property name="timeout" value="${redis.timeout}" />
	<property name="database" value="${redis.default.db}"></property>
	<constructor-arg index="0" ref="jedisPoolConfig" />
</bean>

   <bean id="stringRedisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
       <property name="connectionFactory" ref="jedisConnectionFactory" />
   </bean>

   <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
       <property name="connectionFactory" ref="jedisConnectionFactory" />
       <property name="keySerializer">
           <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
       </property>
       <property name="valueSerializer">
           <bean class="com.xxx.xxx.xxx.redis.serializer.JsonRedisSerializer" />
       </property>

       <property name="hashKeySerializer">
           <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
       </property>

       <property name="hashValueSerializer">
           <bean class="com.xxx.xxx.xxx.redis.serializer.JsonRedisSerializer" />
       </property>
   </bean>

序列化操作类

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;

import com.alibaba.fastjson.JSON;

public class JsonRedisSerializer implements RedisSerializer<Object> {

    private static final String CHARSET_NAME = "UTF-8";

    private static final Logger logger = LoggerFactory.getLogger(JsonRedisSerializer.class);

    @Override
    public byte[] serialize(Object data) throws SerializationException {
        if (data == null) {
            return null;
        }

        try {
            // 先转成String
            String json = JSON.toJSONString(data);
            // 包装
            SerializerObject so = new SerializerObject();
            so.setClassName(data.getClass().getName());
            so.setJsonString(json);
            // 再转
            String serializerStr = JSON.toJSONString(so);

            return serializerStr.getBytes(CHARSET_NAME);
        } catch (Exception e) {
            logger.error("RedisSerializer序列化异常", e);
            throw new SerializationException("RedisSerializer序列化异常");
        }
    }

    @Override
    public Object deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null) {
            return null;
        }
        try {
            String serializerStr = new String(bytes, CHARSET_NAME);
            SerializerObject deSerObj = JSON.parseObject(serializerStr, SerializerObject.class);

            Class<?> t = Class.forName(deSerObj.getClassName());
            return JSON.parseObject(deSerObj.getJsonString(), t);

        } catch (Exception e) {
            logger.error("RedisSerializer反序列化异常", e);
            throw new SerializationException("RedisSerializer反序列化异常");
        }
    }

}

class SerializerObject {
    private String className;
    private String jsonString;

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public String getJsonString() {
        return jsonString;
    }

    public void setJsonString(String jsonString) {
        this.jsonString = jsonString;
    }

}

简单例子

@Service("redisService")
public class RedisServiceImpl implements RedisService {

    @Resource(name = "stringRedisTemplate")
    private RedisTemplate<String, String> template;

    @Resource(name = "stringRedisTemplate")
    private ListOperations<String, String> listOps;

    @Resource(name = "stringRedisTemplate")
    private HashOperations<String, String, String> hashOps;

    @Resource(name = "stringRedisTemplate")
    private SetOperations<String, String> setOps;

    @Override
    public void delKey(String key) {
        template.delete(key);
    }

    @Override
    public boolean hasKey(String key) {
        return template.hasKey(key);
    }

    @Override
    public Long setAdd(String key, String... values) {
        return setOps.add(key, values);
        // return template.boundSetOps(key).add(values);
    }

    @Override
    public Long setSize(String key) {
        return setOps.size(key);
        // return template.boundSetOps(key).size();
    }

    @Override
    public Long rightPushList(String key, String value) {
        return listOps.rightPush(key, value);
        // return template.boundListOps(key).rightPush(value);
    }

    @Override
    public String leftPopList(String key) {
        return listOps.leftPop(key);
        // return template.boundListOps(key).leftPop();
    }

    @Override
    public Long listSize(String key) {
        return listOps.size(key);
        // return template.boundListOps(key).size();
    }
    ...
    ...

类	操作
ValueOperations	Redis String/Value 操作
ListOperations	Redis List 操作
SetOperations	Redis Set 操作
ZSetOperations	Redis Sort Set 操作
HashOperations	Redis Hash 操作

类	约束
BoundValueOperations	Redis String/Value key 约束
BoundListOperations	Redis List key 约束
BoundSetOperations	Redis Set key 约束
BoundZSetOperations	Redis Sort Set key 约束
BoundHashOperations	Redis Hash key 约束

交换器 Exchanger

发表于 2018-05-22 分类于 Java ， Concurrent 本文字数： 349 阅读时长 ≈ 1 分钟

交换器 Exchanger

Exchanger 是 Java 并发包中的一个同步工具类，位于 java.util.concurrent 包下。它提供了一个用于在两个线程之间交换数据的同步点。Exchanger 用于当两个线程希望在某个同步点交换数据时，可以使用它来实现数据交换。

Exchanger 的工作机制如下：

两个线程通过调用 exchange 方法来到达同步点。
第一个线程调用 exchange 方法时，会等待第二个线程也调用 exchange 方法。
当两个线程都调用 exchange 方法时，它们会交换数据，即第一个线程将自己的数据传递给第二个线程，同时接收第二个线程的数据。

下面是一个简单的示例，展示了如何使用 Exchanger 在两个线程之间交换数据：

import java.util.concurrent.Exchanger;

public class ExchangerExample {
    public static void main(String[] args) {
        Exchanger<String> exchanger = new Exchanger<>();

        // 线程A
        new Thread(() -> {
            try {
                String dataA = "Data from A";
                System.out.println("Thread A is exchanging data: " + dataA);
                String receivedData = exchanger.exchange(dataA);
                System.out.println("Thread A received: " + receivedData);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();

        // 线程B
        new Thread(() -> {
            try {
                String dataB = "Data from B";
                System.out.println("Thread B is exchanging data: " + dataB);
                String receivedData = exchanger.exchange(dataB);
                System.out.println("Thread B received: " + receivedData);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}

Exchanger 通常用于一些需要线程之间进行数据交换的场景，比如生产者-消费者模型中，当生产者和消费者希望交换缓冲区时，可以使用 Exchanger 来实现。

倒计时闩锁 Countdownlatch

发表于 2018-05-22 分类于 Java ， Concurrent 本文字数： 315 阅读时长 ≈ 1 分钟

倒计时闩锁 CountDownLatch

CountDownLatch类位于java.util.concurrent包下，利用它可以实现类似计数器的功能。比如有一个任务A，它要等待其他4个任务执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了。

CountDownLatch类只提供了一个构造器：

1	public CountDownLatch(int count) { }; //参数count为计数值

然后下面这3个方法是CountDownLatch类中最重要的方法：

public void await() throws InterruptedException { };   //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  //和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public void countDown() { };  //将count值减1

例子：

public class Test {
     public static void main(String[] args) {   
         final CountDownLatch latch = new CountDownLatch(2);
 
         new Thread(){
             public void run() {
                 try {
                     System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
                    Thread.sleep(3000);
                    System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
                    latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
             };
         }.start();
 
         new Thread(){
             public void run() {
                 try {
                     System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
                     Thread.sleep(3000);
                     System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
                     latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
             };
         }.start();
 
         try {
             System.out.println("等待2个子线程执行完毕...");
            latch.await();
            System.out.println("2个子线程已经执行完毕");
            System.out.println("继续执行主线程");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
     }
}

信号量 Semaphore

发表于 2018-05-18 分类于 Java ， Concurrent 本文字数： 442 阅读时长 ≈ 2 分钟

信号量 Semaphore

Semaphore可以控同时访问的线程个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。

Semaphore类位于java.util.concurrent包下，它提供了2个构造器：

public Semaphore(int permits) {          //参数permits表示许可数目，即同时可以允许多少线程进行访问
    sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) {    //这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可
    sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}

重要的几个方法，首先是acquire()、release()方法：

public void acquire() throws InterruptedException {  }     //获取一个许可
public void acquire(int permits) throws InterruptedException { }    //获取permits个许可
public void release() { }          //释放一个许可
public void release(int permits) { }    //释放permits个许可

public boolean tryAcquire() { };    //尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { };  //尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
public boolean tryAcquire(int permits) { }; //尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { }; //尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false

例子：

public class Test {
    public static void main(String[] args) {
        int N = 8;            //工人数
        Semaphore semaphore = new Semaphore(5); //机器数目
        for(int i=0;i<N;i++)
            new Worker(i,semaphore).start();
    }
 
    static class Worker extends Thread{
        private int num;
        private Semaphore semaphore;
        public Worker(int num,Semaphore semaphore){
            this.num = num;
            this.semaphore = semaphore;
        }
 
        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println("工人"+this.num+"占用一个机器在生产...");
                Thread.sleep(2000);
                System.out.println("工人"+this.num+"释放出机器");
                semaphore.release();           
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

同步屏障 cyclicbarrier

发表于 2018-05-15 分类于 Java ， Concurrent 本文字数： 179 阅读时长 ≈ 1 分钟

同步屏障 CyclicBarrier

CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。CyclicBarrier默认的构造方法是CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。

public class CyclicBarrierTest {

   static CyclicBarrier c = new CyclicBarrier(2);

   public static void main(String[] args) {
       new Thread(new Runnable() {

           @Override
           public void run() {
               try {
                   c.await();
               } catch (Exception e) {

               }
               System.out.println(1);
           }
       }).start();

       try {
           c.await();
       } catch (Exception e) {

       }
       System.out.println(2);
   }

}