Go语言net/http包详解

发表于 2021-08-31

这是我参与8月更文挑战的第31天，活动详情查看：8月更文挑战

Go的http有两个核心功能：Conn、ServeMux

Go 提供了一系列用于创建 Web 服务器的标准库，而且通过 Go 创建一个服务器的步骤非常简单，只要通过 net/http 包调用 ListenAndServe 函数并传入网络地址以及负责处理请求的处理器( handler ) 作为参数就可以了。

如果网络地址参数为空字符串，那么服务器默认使用 80 端口进行网络连接；如果处理器参数为 nil，那么服务器将使用默认的多路复用器 DefaultServeMux，

Conn的goroutine

与我们一般编写的http服务器不同, Go为了实现高并发和高性能, 使用了goroutines来处理Conn的读写事件, 这样每个请求都能保持独立，相互不会阻塞，可以高效的响应网络事件。这是Go高效的保证。

Go在等待客户端请求里面是这样写的：

go复制代码c, err := srv.newConn(rw)
if err != nil {
	continue
}
go c.serve()

这里我们可以看到客户端的每次请求都会创建一个Conn，这个Conn里面保存了该次请求的信息，然后再传递到对应的handler，该handler中便可以读取到相应的header信息，这样保证了每个请求的独立性。

ServeMux的自定义

我们前面小节讲述conn.server的时候，其实内部是调用了http包默认的路由器，通过路由器把本次请求的信息传递到了后端的处理函数。那么这个路由器是怎么实现的呢？

它的结构如下：

go复制代码type ServeMux struct {
	mu sync.RWMutex   //锁，由于请求涉及到并发处理，因此这里需要一个锁机制
	m  map[string]muxEntry  // 路由规则，一个string对应一个mux实体，这里的string就是注册的路由表达式
	hosts bool // 是否在任意的规则中带有host信息
}

下面看一下muxEntry

csharp复制代码type muxEntry struct {
	explicit bool   // 是否精确匹配
	h        Handler // 这个路由表达式对应哪个handler
	pattern  string  //匹配字符串
}

接着看一下Handler的定义

1
2
3

go复制代码type Handler interface {
	ServeHTTP(ResponseWriter, *Request)  // 路由实现器
}

Handler是一个接口，但是前一小节中的sayhelloName函数并没有实现ServeHTTP这个接口，为什么能添加呢？原来在http包里面还定义了一个类型HandlerFunc,我们定义的函数sayhelloName就是这个HandlerFunc调用之后的结果，这个类型默认就实现了ServeHTTP这个接口，即我们调用了HandlerFunc(f),强制类型转换f成为HandlerFunc类型，这样f就拥有了ServeHTTP方法。

scss复制代码type HandlerFunc func(ResponseWriter, *Request)

// ServeHTTP calls f(w, r).
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
	f(w, r)
}

路由器里面存储好了相应的路由规则之后，那么具体的请求又是怎么分发的呢？请看下面的代码，默认的路由器实现了ServeHTTP：

erlang复制代码func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
	if r.RequestURI == "*" {
		w.Header().Set("Connection", "close")
		w.WriteHeader(StatusBadRequest)
		return
	}
	h, _ := mux.Handler(r)
	h.ServeHTTP(w, r)
}

如上所示路由器接收到请求之后，如果是*那么关闭链接，不然调用mux.Handler(r)返回对应设置路由的处理Handler，然后执行h.ServeHTTP(w, r)

也就是调用对应路由的handler的ServerHTTP接口，那么mux.Handler(r)怎么处理的呢？

scss复制代码func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) {
	if r.Method != "CONNECT" {
		if p := cleanPath(r.URL.Path); p != r.URL.Path {
			_, pattern = mux.handler(r.Host, p)
			return RedirectHandler(p, StatusMovedPermanently), pattern
		}
	}	
	return mux.handler(r.Host, r.URL.Path)
}

func (mux *ServeMux) handler(host, path string) (h Handler, pattern string) {
	mux.mu.RLock()
	defer mux.mu.RUnlock()

	// Host-specific pattern takes precedence over generic ones
	if mux.hosts {
		h, pattern = mux.match(host + path)
	}
	if h == nil {
		h, pattern = mux.match(path)
	}
	if h == nil {
		h, pattern = NotFoundHandler(), ""
	}
	return
}

Go其实支持外部实现的路由器 ListenAndServe的第二个参数就是用以配置外部路由器的，它是一个Handler接口，即外部路由器只要实现了Handler接口就可以,我们可以在自己实现的路由器的ServeHTTP里面实现自定义路由功能。

如下代码所示，我们自己实现了一个简易的路由器

go复制代码package main

import (
	"fmt"
	"net/http"
)

type MyMux struct {
}

func (p *MyMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path == "/" {
		sayhelloName(w, r)
		return
	}
	http.NotFound(w, r)
	return
}

func sayhelloName(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello myroute!")
}

func main() {
	mux := &MyMux{}
	http.ListenAndServe(":9090", mux)
}

如果网络地址参数为空字符串，那么服务器默认使用 80 端口进行网络连接；如果处理器参数为 nil，那么服务器将使用默认的多路复用器 DefaultServeMux，当然，我们也可以通过调用 NewServeMux 函数创建一个多路复用器。多路复用器接收到用户的请求之后根据请求的 URL 来判断使用哪个处理器来处理请求，找到后就会重定向到对应的处理器来处理请求

使用默认的多路复用器（DefaultServeMux）

go复制代码package main

import (
	"fmt"
	"net/http"
)

type DefineServerMux struct{}

func (dsm *DefineServerMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintln(w, "创建自定义的多路复用处理器defineServerMux")
}

func ServeHTTP(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintln(w, "HandleFunc将一个普通的函数ServeHTTP包装成Handle")
}

func main() {

	defineServerMux := DefineServerMux{}

	http.Handle("/defineServerMux", &defineServerMux)
	http.HandleFunc("/",ServeHTTP)

	//这里我们看到了，第二个参数要求传递的是一个handle,但是为什么handle设置为nil
	http.ListenAndServe(":8080", nil)

}

使用自己创建的多路复用器

在创建服务器时，我们还可以通过 NewServeMux 方法创建一个多路复用器

1	go复制代码func NewServeMux() *ServeMux

NewServeMux创建并返回一个新的*ServeMux

go复制代码package main

import (
	"fmt"
	"net/http"
)

type DefineServerMux struct{}

func (dsm *DefineServerMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintln(w, "创建自定义的多路复用处理器defineServerMux")
}

func main() {

	defineServerMux := DefineServerMux{}

	http.Handle("/defineServerMux", &defineServerMux)
	http.ListenAndServe(":8080", nil)

}

结构体 ServeMux

1
2
3

go复制代码type ServeMux struct {
    // 内含隐藏或非导出字段
}

ServeMux类型是HTTP请求的多路转接器。它会将每一个接收的请求的URL与一个注册模式的列表进行匹配，并调用和URL最匹配的模式的处理器。

结构体 ServeMux 的相关方法

func (*ServeMux)

1	go复制代码func (mux *ServeMux) Handle(pattern string, handler Handler)

Handle注册HTTP处理器handler和对应的模式pattern。如果该模式已经注册有一个处理器，Handle会panic。

func (*ServeMux)

1	go复制代码func (mux ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, Request))

HandleFunc注册一个处理器函数handler和对应的模式pattern。

func (*ServeMux)

1	scss复制代码func (mux ServeMux) Handler(r Request) (h Handler, pattern string)

Handler根据r.Method、r.Host和r.URL.Path等数据，返回将用于处理该请求的HTTP处理器。它总是返回一个非nil的处理器。如果路径不是它的规范格式，将返回内建的用于重定向到等价的规范路径的处理器。

Handler也会返回匹配该请求的的已注册模式；在内建重定向处理器的情况下，pattern会在重定向后进行匹配。如果没有已注册模式可以应用于该请求，本方法将返回一个内建的”404 page not found”处理器和一个空字符串模式。

func (*ServeMux)

1	scss复制代码func (mux ServeMux) ServeHTTP(w ResponseWriter, r Request)

ServeHTTP将请求派遣到与请求的URL最匹配的模式对应的处理器。

使用实现ServerHTTP的类型来自定义的处理器处理请求

go复制代码package main

import (
	"fmt"
	"net/http"
)

type MyHandlers struct{}

func (m *MyHandlers) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintln(w, "通过自己创建的处理器处理请求！")
}

func main() {

	myHandler := MyHandlers{}

	http.Handle("/myHandler", &myHandler)
	http.ListenAndServe(":8080", nil)

}

通过 Server 结构对服务器进行更详细的配置

Server结构体也定义了实现http的相关方法

go复制代码package main

import (
	"fmt"
	"net/http"
	"strings"
	"time"
)

type MyDefinitionMux struct{}

func (m *MyDefinitionMux)sayhelloName(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello afei!") // 这个写入到 w 的是输出到客户端的
}

func (h *MyDefinitionMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintln(w, "测试通过 Server 结构详细配置服务器")
	//h.sayhelloName(w,r)

}

func main() {
	myDefinitionMux := MyDefinitionMux{}
	//对net/http包中 Server 结构体设置
	server := http.Server{
		Addr: ":8080",
		//自定义handle
		Handler: &myDefinitionMux,
		ReadTimeout: 2 * time.Second,
	}
	server.ListenAndServe()
}

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

Spring5参考指南 Environment

发表于 2021-08-31

本文已参与掘金创作者训练营第三期「高产更文」赛道，详情查看：掘力计划｜创作者训练营第三期正在进行，「写」出个人影响力。

Spring的Environment接口有两个关键的作用：1. Profile， 2.properties。可以看下该接口的定义：

java复制代码public interface Environment extends PropertyResolver {

	/**
	 * Return the set of profiles explicitly made active for this environment. Profiles
	 * are used for creating logical groupings of bean definitions to be registered
	 * conditionally, for example based on deployment environment. Profiles can be
	 * activated by setting {@linkplain AbstractEnvironment#ACTIVE_PROFILES_PROPERTY_NAME
	 * "spring.profiles.active"} as a system property or by calling
	 * {@link ConfigurableEnvironment#setActiveProfiles(String...)}.
	 * <p>If no profiles have explicitly been specified as active, then any
	 * {@linkplain #getDefaultProfiles() default profiles} will automatically be activated.
	 * @see #getDefaultProfiles
	 * @see ConfigurableEnvironment#setActiveProfiles
	 * @see AbstractEnvironment#ACTIVE_PROFILES_PROPERTY_NAME
	 */
	String[] getActiveProfiles();

	/**
	 * Return the set of profiles to be active by default when no active profiles have
	 * been set explicitly.
	 * @see #getActiveProfiles
	 * @see ConfigurableEnvironment#setDefaultProfiles
	 * @see AbstractEnvironment#DEFAULT_PROFILES_PROPERTY_NAME
	 */
	String[] getDefaultProfiles();

	/**
	 * Return whether one or more of the given profiles is active or, in the case of no
	 * explicit active profiles, whether one or more of the given profiles is included in
	 * the set of default profiles. If a profile begins with '!' the logic is inverted,
	 * i.e. the method will return {@code true} if the given profile is <em>not</em> active.
	 * For example, {@code env.acceptsProfiles("p1", "!p2")} will return {@code true} if
	 * profile 'p1' is active or 'p2' is not active.
	 * @throws IllegalArgumentException if called with zero arguments
	 * or if any profile is {@code null}, empty, or whitespace only
	 * @see #getActiveProfiles
	 * @see #getDefaultProfiles
	 * @see #acceptsProfiles(Profiles)
	 * @deprecated as of 5.1 in favor of {@link #acceptsProfiles(Profiles)}
	 */
	@Deprecated
	boolean acceptsProfiles(String... profiles);

	/**
	 * Return whether the {@linkplain #getActiveProfiles() active profiles}
	 * match the given {@link Profiles} predicate.
	 */
	boolean acceptsProfiles(Profiles profiles);

}

它继承了PropertyResolver：

java复制代码public interface PropertyResolver {

	/**
	 * Return whether the given property key is available for resolution,
	 * i.e. if the value for the given key is not {@code null}.
	 */
	boolean containsProperty(String key);

	/**
	 * Return the property value associated with the given key,
	 * or {@code null} if the key cannot be resolved.
	 * @param key the property name to resolve
	 * @see #getProperty(String, String)
	 * @see #getProperty(String, Class)
	 * @see #getRequiredProperty(String)
	 */
	@Nullable
	String getProperty(String key);

	/**
	 * Return the property value associated with the given key, or
	 * {@code defaultValue} if the key cannot be resolved.
	 * @param key the property name to resolve
	 * @param defaultValue the default value to return if no value is found
	 * @see #getRequiredProperty(String)
	 * @see #getProperty(String, Class)
	 */
	String getProperty(String key, String defaultValue);

	/**
	 * Return the property value associated with the given key,
	 * or {@code null} if the key cannot be resolved.
	 * @param key the property name to resolve
	 * @param targetType the expected type of the property value
	 * @see #getRequiredProperty(String, Class)
	 */
	@Nullable
	<T> T getProperty(String key, Class<T> targetType);

	/**
	 * Return the property value associated with the given key,
	 * or {@code defaultValue} if the key cannot be resolved.
	 * @param key the property name to resolve
	 * @param targetType the expected type of the property value
	 * @param defaultValue the default value to return if no value is found
	 * @see #getRequiredProperty(String, Class)
	 */
	<T> T getProperty(String key, Class<T> targetType, T defaultValue);

	/**
	 * Return the property value associated with the given key (never {@code null}).
	 * @throws IllegalStateException if the key cannot be resolved
	 * @see #getRequiredProperty(String, Class)
	 */
	String getRequiredProperty(String key) throws IllegalStateException;

	/**
	 * Return the property value associated with the given key, converted to the given
	 * targetType (never {@code null}).
	 * @throws IllegalStateException if the given key cannot be resolved
	 */
	<T> T getRequiredProperty(String key, Class<T> targetType) throws IllegalStateException;

	/**
	 * Resolve ${...} placeholders in the given text, replacing them with corresponding
	 * property values as resolved by {@link #getProperty}. Unresolvable placeholders with
	 * no default value are ignored and passed through unchanged.
	 * @param text the String to resolve
	 * @return the resolved String (never {@code null})
	 * @throws IllegalArgumentException if given text is {@code null}
	 * @see #resolveRequiredPlaceholders
	 * @see org.springframework.util.SystemPropertyUtils#resolvePlaceholders(String)
	 */
	String resolvePlaceholders(String text);

	/**
	 * Resolve ${...} placeholders in the given text, replacing them with corresponding
	 * property values as resolved by {@link #getProperty}. Unresolvable placeholders with
	 * no default value will cause an IllegalArgumentException to be thrown.
	 * @return the resolved String (never {@code null})
	 * @throws IllegalArgumentException if given text is {@code null}
	 * or if any placeholders are unresolvable
	 * @see org.springframework.util.SystemPropertyUtils#resolvePlaceholders(String, boolean)
	 */
	String resolveRequiredPlaceholders(String text) throws IllegalArgumentException;

}

Profile是一个Bean的逻辑分组，只有在给定的配置文件处于活动状态时，才会在容器中注册。

Properties主要用来从各种源：属性文件、JVM系统属性、系统环境变量、JNDI、servlet上下文参数、特殊属性对象、映射对象等读取属性的定义。

Profiles

在开发中，我们可以需要在不同的环境定义不同的配置，例如：

在开发中处理内存中的数据源，而不是在QA或生产中从JNDI中查找相同的数据源。
仅在将应用程序部署到性能环境中时注册监控基础结构。
为客户A和客户B部署注册定制的bean实现。

假如我们有两个数据源，一个是在测试环境使用，一个是在线上环境使用，则可以通过profile来指定不同的环境。如下所示：

java复制代码@Configuration
@Profile("development")
public class StandaloneDataConfig {

    @Bean
    public DataSource dataSource() {
        return new EmbeddedDatabaseBuilder()
                .setType(EmbeddedDatabaseType.HSQL)
                .addScript("classpath:com/bank/config/sql/schema.sql")
                .addScript("classpath:com/bank/config/sql/test-data.sql")
                .build();
    }
}

java复制代码@Configuration
@Profile("production")
public class JndiDataConfig {

    @Bean(destroyMethod="")
    public DataSource dataSource() throws Exception {
        Context ctx = new InitialContext();
        return (DataSource) ctx.lookup("java:comp/env/jdbc/datasource");
    }
}

@Profile里面的表达式可以是简单的字符串，也可以支持运算符，如：

! 逻辑非
& 逻辑与
| 逻辑或

可以将@Profile用作元注解，以创建自定义组合注解。以下示例定义了一个自定义的@Production注解，您可以将其用作@Profile（“production”）的替换：

java复制代码@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Profile("production")
public @Interface Production {
}

@Profile也可以用在方法级别用来包含一个特殊的bean或者配置类。如下所示：

java复制代码@Configuration
public class AppConfig {

    @Bean("dataSource")
    @Profile("development") 
    public DataSource standaloneDataSource() {
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.HSQL)
            .addScript("classpath:com/bank/config/sql/schema.sql")
            .addScript("classpath:com/bank/config/sql/test-data.sql")
            .build();
    }

    @Bean("dataSource")
    @Profile("production") 
    public DataSource jndiDataSource() throws Exception {
        Context ctx = new InitialContext();
        return (DataSource) ctx.lookup("java:comp/env/jdbc/datasource");
    }
}

Profiles在XML中使用

可以在XML中使用profile属性，如下所示：

xml复制代码<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xsi:schemaLocation="...">

    <!-- other bean definitions -->

    <beans profile="development">
        <jdbc:embedded-database id="dataSource">
            <jdbc:script location="classpath:com/bank/config/sql/schema.sql"/>
            <jdbc:script location="classpath:com/bank/config/sql/test-data.sql"/>
        </jdbc:embedded-database>
    </beans>

    <beans profile="production">
        <jee:jndi-lookup id="dataSource" jndi-name="java:comp/env/jdbc/datasource"/>
    </beans>
</beans>

激活Profile

上面我们定义好了Profile，但是怎么激活他们？

激活一个概要文件可以用几种方法完成，但最简单的方法是通过应用程序上下文提供的环境API以编程方式完成。以下示例显示了如何执行此操作：

java复制代码    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
        ctx.getEnvironment().setActiveProfiles("development");
        ctx.register(AppConfig.class, StandaloneDataConfig.class, JndiDataConfig.class);
        ctx.refresh();
    }

此外，还可以通过spring.profiles.active属性声明性地激活概要文件，该属性可以通过系统环境变量、jvm系统属性、web.xml中的servlet上下文参数指定，甚至可以作为JNDI中的条目指定.
如下所示：

-Dspring.profiles.active=”profile1,profile2”

你也可以同时激活多个pofile

ctx.getEnvironment().setActiveProfiles(“profile1”, “profile2”);

默认Profile

默认的Profile表示该Profile默认被激活，如下所示：

java复制代码@Configuration
@Profile("default")
public class DefaultDataConfig {

    @Bean
    public DataSource dataSource() {
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.HSQL)
            .addScript("classpath:com/bank/config/sql/schema.sql")
            .build();
    }
}

如果没有Profile被激活，那么dataSource就会被创建，你可以看成创建bean的默认方式。如果其他的Profile被激活了，那么默认的Profile就不会被使用。

您可以在环境中使用SetDefaultProfiles（）更改默认profile的名称，或者声明性地使用spring.profiles.default属性更改默认概要文件的名称。

PropertySource

下面是使用PropertySource的例子：

java复制代码    public static void main(String[] args) {
        ApplicationContext ctx = new GenericApplicationContext();
        Environment env = ctx.getEnvironment();
        boolean containsMyProperty = env.containsProperty("my-property");
        System.out.println("Does my environment contain the 'my-property' property? " + containsMyProperty);
    }

这里Spring查询是否定义了my-property属性，这里的StandardEnvironment定义了两组PropertySource对象进行查询，

java复制代码	/** System environment property source name: {@value}. */
	public static final String SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME = "systemEnvironment";

	/** JVM system properties property source name: {@value}. */
	public static final String SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME = "systemProperties";

一个表示一组JVM系统属性（System.GetProperties（）），另一个表示一组系统环境变量（System.getEnv（））。

对于常见的StandardServletEnvironment，property的查询优先级如下：

ServletConfig参数（如果适用-例如，对于DispatcherServlet上下文）
ServletContext参数（web.xml context-param 项）
JNDI环境变量（Java:COMP/Env/条目）
JVM系统属性（-d命令行参数）
JVM系统环境（操作系统环境变量）

使用@PropertySource

@PropertySource注解提供了方便和声明式的机制为Spring的添加PropertySource.

下面的@Configuration类使用@PropertySource 来调用testBean.getName() 返回 myTestBean：

java复制代码@Configuration
@PropertySource("classpath:app.properties")
public class PropertiesConfig {


    @Autowired
    Environment env;

    @Bean
    public TestBean testBean() {
        TestBean testBean = new TestBean();
        testBean.setName(env.getProperty("testbean.name"));
        return testBean;
    }
}

@Propertysource资源位置中存在的任何$…占位符将根据已针对环境注册的属性源集进行解析，如下示例所示：

1	java复制代码@PropertySource("classpath:/com/${my.placeholder:default/path}/app.properties")

假设my.placeholder存在于已注册的某个属性源中（例如，系统属性或环境变量），则将占位符解析为相应的值。如果不是，则default/path用作默认值。如果未指定默认值且无法解析属性，则将引发IllegalArgumentException。

本节的例子可以参考Environment

更多教程请参考 flydean的博客

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

京东-Java中级面试题分享- 1 、哪些情况下的对象会被垃

发表于 2021-08-31

这是我参与 8 月更文挑战的第 31 天，活动详情查看： 8月更文挑战

)

**1** **、哪些情况下的对象会被垃圾回收机制处理掉？**

利用可达性分析算法，虚拟机会将一些对象定义为 GC Roots，从 GC Roots 出发沿着引用链向下寻找，如果**某个对象不能通过 GC Roots 寻找到**，虚拟机就认为该对象可以被回收掉。

1.1哪些对象可以被看做是 GC Roots 呢？

1）虚拟机栈（栈帧中的本地变量表）中引用的对象；

2）方法区中的类静态属性引用的对象，常量引用的对象；

3）本地方法栈中 JNI(Native 方法）引用的对象；

1.2对象不可达，一定会被垃圾收集器回收么？

即使不可达，对象也不一定会被垃圾收集器回收，

1）先判断对象是否有必要执行 finalize() 方法，对象必须重写 finalize()方法且没有被运行过。

2）若有必要执行，会把对象放到一个队列中，JVM 会开一个线程去回收它们，这是对象最后一次可以逃逸清理的机会。

**2** **、讲一下常见编码方式？**

编码的意义：计算机中存储的最小单元是一个字节即 8bit，所能表示的字符范围是 255 个，而人类要表示的符号太多，无法用一个字节来完全表示，固需要将符号编码，将各种语言翻译成计算机能懂的语言。

1）ASCII 码：总共 128 个，用一个字节的低 7 位表示，0〜31 控制字符如换回车删除等；32~126是打印字符，可通过键盘输入并显示出来；

2）ISO-8859-1,用来扩展 ASCII 编码，256 个字符，涵盖了大多数西欧语言字符。

3）GB2312:双字节编码，总编码范围是 A1-A7,A1-A9 是符号区，包含 682 个字符，B0-B7 是汉字区，包含 6763 个汉字；

4）GBK 为了扩展 GB2312,加入了更多的汉字，编码范围是 8140~FEFE，有 23940 个码位，能表示 21003 个汉字。

5）UTF-16: ISO 试图想创建一个全新的超语言字典，世界上所有语言都可通过这本字典Unicode 来相互翻译，而 UTF-16 定义了 Unicode 字符在计算机中存取方法，用两个字节来表示 Unicode 转化格式。不论什么字符都可用两字节表示，即 16bit，固叫 UTF-16。

6）UTF-8：UTF-16 统一采用两字节表示一个字符，但有些字符只用一个字节就可表示，浪费存储空间，而 UTF-8 采用一种变长技术，每个编码区域有不同的字码长度。不同类型的字符可以由1~6 个字节组成。

**3 **、 **utf-8 **编码中的中文占几个字节； **int** **型几个字节？**

utf-8 是一种变长编码技术，utf-8 编码中的中文占用的字节不确定，可能 2 个、3 个、4 个，

int 型占 4 个字节。

**4** **、静态代理和动态代理的区别，什么场景使用？**

代理是一种常用的设计模式，目的是：为其他对象提供一个代理以控制对某个对象的访问，将两个类的关系解耦。代理类和委托类都要实现相同的接口，因为代理真正调用的是委托类的方法。

区别：

静态代理：由程序员创建或是由特定工具生成，在代码编译时就确定了被代理的类是哪一个是静态代理。静态代理通常只代理一个类；
动态代理：在代码运行期间，运用反射机制动态创建生成。动态代理代理的是一个接口下的多个实现类；

实现步骤： a. 实现 InvocationHandler 接口创建自己的调用处理器； b. 给 Proxy 类提供ClassLoader 和代理接口类型数组创建动态代理类；c.利用反射机制得到动态代理类的构造函数；d.利用动态代理类的构造函数创建动态代理类对象；

使用场景：Retrofit 中直接调用接口的方法；Spring 的 AOP 机制；

**5 **、 **Java** **的异常体系**

Java 中 Throwable 是所有异常和错误的超类，两个直接子类是 Error（错误）和 Exception（异常）：

1）Error 是程序无法处理的错误，由 JVM 产生和抛出，如 OOM、ThreadDeath 等。这些异常发生时，JVM 一般会选择终止程序。

2）Exception 是程序本身可以处理的异常，又分为运行时异常(RuntimeException)(也叫Checked Eception) 和非运行时异常 ( 不检查异常 Unchecked Exception) 。运行时异常有 NullPointerException\IndexOutOfBoundsException 等，这些异常一般是由程序逻辑错误引起的，应尽可能避免。非运行时异常有IOException\SQLException\FileNotFoundException 以及由用户自定义的 Exception 异常等。

**6** **、谈谈你对解析与分派的认识。**

解析指方法在运行前，即编译期间就可知的，有一个确定的版本，运行期间也不会改变。解析是静态的，在类加载的解析阶段就可将符号引用转变成直接引用。

分派可分为静态分派和动态分派，重载属于静态分派，覆盖属于动态分派。静态分派是指在重载时通过参数的静态类型而非实际类型作为判断依据，在编译阶段，编译器可根据参数的静态类型决定使用哪一个重载版本。动态分派则需要根据实际类型来调用相应的方法。

**7** **、修改对象** **A** **的** **equals** **方法的签名，那么使用** ****HashMap 存放这个对象实例的时候，会调用哪个**** equals 方法？

会调用对象的 equals 方法，如果对象的 equals 方法没有被重写，equals 方法和==都是比较栈内局部变量表中指向堆内存地址值是否相等。

**8 **、 **Java** **中实现多态的机制是什么？**

多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编译时不确定，在运行期间才确定，一个引用变量到底会指向哪个类的实例。这样就可以不用修改源程序，就可以让引用变量绑定到各种不同的类实现上。Java 实现多态有三个必要条件：继承、重定、向上转型，在多态中需要将子类的引用赋值给父类对象，只有这样该引用才能够具备调用父类方法和子类的方法。

**9** **、如何将一个** **Java** **对象序列化到文件里？**

ObjectOutputStream.writeObject()负责将指定的流写入，ObjectInputStream.readObject()从指定流读取序列化数据。

scss复制代码
//写入try {

ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("D:/student.txt"));

os.writeObject(studentList); os.close();

} catch(FileNotFoundException e) { e.printStackTrace();

} catch(IOException e) { e.printStackTrace();

}

**10** **、说说你对** **Java** **反射的理解**

在运行状态中，对任意一个类，都能知道这个类的所有属性和方法，对任意一个对象，都能调用它的任意一个方法和属性。这种能动态获取信息及动态调用对象方法的功能称为 java 语言的反射机制。

反射的作用：开发过程中，经常会遇到某个类的某个成员变量、方法或属性是私有的，或只对系统应用开放，这里就可以利用 java 的反射机制通过反射来获取所需的私有成员或是方法。

获取类的 Class 对象实例 Class clz = Class.forName(“com.zhenai.api.Apple”);

1）根据 Class 对象实例获取 Constructor 对象 Constructor appConstructor = clz.getConstructor();

2）使用 Constructor 对象的 newInstance 方法获取反射类对象 Object appleObj = appConstructor.newInstance();

3）获取方法的 Method 对象 Method setPriceMethod = clz.getMethod(“setPrice”, int.class);

4）利用 invoke 方法调用方法 setPriceMethod.invoke(appleObj, 14);

5）通过 getFields()可以获取 Class 类的属性，但无法获取私有属性，而 getDeclaredFields()可以获取到包括私有属性在内的所有属性。带有 Declared 修饰的方法可以反射到私有的方法，没有 Declared 修饰的只能用来反射公有的方法，其他如 Annotation\Field\Constructor 也是如此。

**11** **、说说你对** **Java** **注解的理解**

注解是通过@interface 关键字来进行定义的，形式和接口差不多，只是前面多了一个@

java复制代码public @interface TestAnnotation {



}

使用时@TestAnnotation 来引用，要使注解能正常工作，还需要使用元注解，它是可以注解到注解上的注解。元标签有@Retention @Documented @Target @Inherited @Repeatable 五种

@Retention 说明注解的存活时间，取值有 RetentionPolicy.SOURCE 注解只在源码阶段保留，在编译器进行编译时被丢弃；RetentionPolicy.CLASS 注解只保留到编译进行的时候，并不会被加载到JVM 中。RetentionPolicy.RUNTIME 可以留到程序运行的时候，它会被加载进入到JVM 中，所以在程序运行时可以获取到它们。

@Documented 注解中的元素包含到 javadoc 中去

@Target 限定注解的应用场景， ElementType.FIELD 给属性进行注解； ElementType.LOCAL_VARIABLE 可以给局部变量进行注解；ElementType.METHOD 可以给方法进行注解；ElementType.PACKAGE 可以给一个包进行注解 ElementType.TYPE 可以给一个类型进行注解，如类、接口、枚举

@Inherited 若一个超类被@Inherited 注解过的注解进行注解，它的子类没有被任何注解应用的话，该子类就可继承超类的注解；

注解的作用：

提供信息给编译器：编译器可利用注解来探测错误和警告信息
编译阶段：软件工具可以利用注解信息来生成代码、html 文档或做其它相应处理；
运行阶段：程序运行时可利用注解提取代码

注解是通过反射获取的，可以通过 Class 对象的 isAnnotationPresent()方法判断它是否应用了某个注解，再通过 getAnnotation()方法获取 Annotation 对象

**12** **、说一下泛型原理，并举例说明**

泛型就是将类型变成参数传入，使得可以使用的类型多样化，从而实现解耦。Java 泛型是在Java1.5 以后出现的，为保持对以前版本的兼容，使用了擦除的方法实现泛型。擦除是指在一定程度无视类型参数 T，直接从 T 所在的类开始向上 T 的父类去擦除，如调用泛型方法，传入类型参数 T 进入方法内部，若没在声明时做类似 public T methodName(T extends Father t){}，Java 就进行了向上类型的擦除，直接把参数 t 当做 Object 类来处理，而不是传进去的 T。即在有泛型的任何类和方法内部，它都无法知道自己的泛型参数，擦除和转型都是在边界上发生，即传进去的参在进入类或方法时被擦除掉，但传出来的时候又被转成了我们设置的 T。在泛型类或方法内，任何涉及到具体类型（即擦除后的类型的子类）操作都不能进行，如new T()，或者 T.play()（play 为某子类的方法而不是擦除后的类的方法）

13 、 Java 中 String 的了解

1）String 类是 final 型，固 String 类不能被继承，它的成员方法也都默认为 final 方法。String 对象一旦创建就固定不变了，对 String 对象的任何改变都不影响到原对象，相关的任何改变操作都会生成新的 String 对象。

2）String 类是通过 char 数组来保存字符串的，String 对 equals 方法进行了重定，比较的是值相等。

1	javascript复制代码String a = "test"; String b = "test"; String c = new String("test");

a、b 和字面上的 test 都是指向 JVM 字符串常量池中的”test”对象，他们指向同一个对象。而new 关键字一定会产生一个对象 test，该对象存储在堆中。所以 new String(“test”)产生了两个对象，保存在栈中的 c 和保存在堆中的 test。而在 java 中根本就不存在两个完全一模一样的字符串对象，故在堆中的 test 应该是引用字符串常量池中的 test。

例：

*String str1 = “abc”; **// *栈中开辟一块空间存放引用 str1 *， *str1 **指向池中 String **常量 “abc” String **str2 = “def **”;* **// *栈中开辟一块空间存放引用 str2 *， *str2 **指向池中 String **常量 “def” String **str3 = str1 *+ **str2;// *栈中开辟一块空间存放引用 str3

//str1+str2 通过 StringBuilder 的最后一步 *toString() *方法返回一个新的 String 对象 “abcdef”

*// *会在堆中开辟一块空间存放此对象，引用 str3 指向堆中的 *(str1+str2) *所返回的新 String *对象。 *System.out.println(str3 == **”abcdef”);//* *返回 false

因为 str3 指向堆中的 **”abcdef”* *对象，而 **”abcdef”* *是字符池中的对象，所以结果为 false *。 *JVM 对 String ***str=”abc” *对象放在常量池是在编译时做的，而 String **str3=str1+str2 **是在运行时才知 *道的， *new **对象也是在运行时才做的。

**14 **、 **String** **为什么要设计成不可变的？**

字符串常量池需要 String 不可变。因为 String 设计成不可变，当创建一个 String 对象时，若此字符串值已经存在于常量池中，则不会创建一个新的对象，而是引用已经存在的对象。如果字符串变量允许必变，会导致各种逻辑错误，如改变一个对象会影响到另一个独立对象。

1）String 对象可以缓存 hashCode。字符串的不可变性保证了 hash 码的唯一性，因此可以缓存 String 的 hashCode，这样不用每次去重新计算哈希码。在进行字符串比较时，可以直接比较hashCode、提高了性能安全

2）安全性。String被许多java类用来当做参数、如URI地址、文件path路径、反射机制所需要的string参数等、若string可变、将会引起各类安全隐患。

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

netty系列之搭建HTTP上传文件服务器简介 GET方

发表于 2021-08-31

这是我参与8月更文挑战的第31天，活动详情查看：8月更文挑战

简介

上一篇的文章中，我们讲到了如何从HTTP服务器中下载文件，和搭建下载文件服务器应该注意的问题，使用的GET方法。本文将会讨论一下常用的向服务器提交数据的POST方法和如何向服务器上传文件。

GET方法上传数据

按照HTTP的规范，PUT一般是向服务器上传数据，虽然不提倡，但是也可以使用GET向服务器端上传数据。

先看下GET客户端的构建中需要注意的问题。

GET请求实际上就是一个URI，URI后面带有请求的参数，netty提供了一个QueryStringEncoder专门用来构建参数内容：

java复制代码// HTTP请求
        QueryStringEncoder encoder = new QueryStringEncoder(get);
        // 添加请求参数
        encoder.addParam("method", "GET");
        encoder.addParam("name", "flydean");
        encoder.addParam("site", "www.flydean.com");
        URI uriGet = new URI(encoder.toString());

有了请求URI，就可以创建HttpRequest了，当然这个HttpRequest中还需要有对应的HTTP head数据：

vbscript复制代码HttpRequest request = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, uriGet.toASCIIString());
        HttpHeaders headers = request.headers();
        headers.set(HttpHeaderNames.HOST, host);
        headers.set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE);
        headers.set(HttpHeaderNames.ACCEPT_ENCODING, HttpHeaderValues.GZIP + "," + HttpHeaderValues.DEFLATE);
        headers.set(HttpHeaderNames.ACCEPT_LANGUAGE, "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2");
        headers.set(HttpHeaderNames.REFERER, uriSimple.toString());
        headers.set(HttpHeaderNames.USER_AGENT, "Netty Simple Http Client side");
        headers.set(HttpHeaderNames.ACCEPT, "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");

        headers.set(
                HttpHeaderNames.COOKIE, ClientCookieEncoder.STRICT.encode(
                        new DefaultCookie("name", "flydean"),
                        new DefaultCookie("site", "www.flydean.com"))
        );

我们知道HttpRequest中只有两部分数据，分别是HttpVersion和HttpHeaders。HttpVersion就是HTTP协议的版本号，HttpHeaders就是设置的header内容。

对于GET请求来说，因为所有的内容都包含在URI中，所以不需要额外的HTTPContent，直接发送HttpRequest到服务器就可以了。

1	ini复制代码channel.writeAndFlush(request);

然后看下服务器端接收GET请求之后怎么进行处理。

服务器端收到HttpObject对象的msg之后，需要将其转换成HttpRequest对象，就可以通过protocolVersion(),uri()和headers()拿到相应的信息。

对于URI中的参数，netty提供了QueryStringDecoder类可以方便的对URI中参数进行解析：

javascript复制代码//解析URL中的参数
            QueryStringDecoder decoderQuery = new QueryStringDecoder(request.uri());
            Map<String, List<String>> uriAttributes = decoderQuery.parameters();
            for (Entry<String, List<String>> attr: uriAttributes.entrySet()) {
                for (String attrVal: attr.getValue()) {
                    responseContent.append("URI: ").append(attr.getKey()).append('=').append(attrVal).append("\r\n");
                }
            }

POST方法上传数据

对于POST请求，它比GET请求多了一个HTTPContent，也就是说除了基本的HttpRequest数据之外，还需要一个PostBody。

如果只是一个普通的POST，也就是POST内容都是key=value的形式，则比较简单，如果POST中包含有文件，那么会比较复杂，需要用到ENCTYPE=”multipart/form-data”。

netty提供了一个HttpPostRequestEncoder类，用于快速对request body进行编码，先看下HttpPostRequestEncoder类的完整构造函数：

1
2
3

java复制代码public HttpPostRequestEncoder(
            HttpDataFactory factory, HttpRequest request, boolean multipart, Charset charset,
            EncoderMode encoderMode)

其中request就是要编码的HttpRequest，multipart表示是否是”multipart/form-data”的格式，charset编码方式，默认情况下是CharsetUtil.UTF_8。encoderMode是编码的模式，目前有三种编码模式，分别是RFC1738，RFC3986和HTML5。

默认情况下的编码模式是RFC1738，这也是大多数form提交数据的编码方式。但是它并不适用于OAUTH，如果要使用OAUTH的话，则可以使用RFC3986。HTML5禁用了multipart/form-data的混合模式。

最后，我们讲讲HttpDataFactory。factory主要用来创建InterfaceHttpData。它有一个minSize参数，如果创建的HttpData大小大于minSize则会存放在磁盘中，否则直接在内存中创建。

InterfaceHttpData有三种HttpData的类型，分别是Attribute, FileUpload和InternalAttribute。

Attribute就是POST请求中传入的属性值。FileUpload就是POST请求中传入的文件，还有InternalAttribute是在encoder内部使用的，这里不过多讨论。

因此，根据传入的minSize参数大小，Attribute和FileUpload可以被分成下面几种：

MemoryAttribute, DiskAttribute or MixedAttribute
MemoryFileUpload, DiskFileUpload or MixedFileUpload

在这一节我们先看一下在POST请求中并不上传文件的处理方式，首先创建HTTP request和PostBody encoder：

vbscript复制代码// 构建HTTP request
        HttpRequest request = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST, uriSimple.toASCIIString());

 HttpPostRequestEncoder bodyRequestEncoder =
                new HttpPostRequestEncoder(factory, request, false);

向request中添加headers：

scss复制代码// 添加headers
        for (Entry<String, String> entry : headers) {
            request.headers().set(entry.getKey(), entry.getValue());
        }

然后再向bodyRequestEncoder中添加form属性：

arduino复制代码// 添加form属性
        bodyRequestEncoder.addBodyAttribute("method", "POST");
        bodyRequestEncoder.addBodyAttribute("name", "flydean");
        bodyRequestEncoder.addBodyAttribute("site", "www.flydean.com");
        bodyRequestEncoder.addBodyFileUpload("myfile", file, "application/x-zip-compressed", false);

注意，上面我们向bodyRequestEncoder中添加了method,name和site这几个属性。然后添加了一个FileUpload。但是因为我们的编码方式并不是”multipart/form-data”，所以这里传递的只是文件名，并不是整个文件。

最后，我们要调用bodyRequestEncoder的finalizeRequest方法，返回最终要发送的request。在finalizeRequest的过程中，还会根据传输数据的大小来设置transfer-encoding是否为chunked。

如果传输的内容比较大，则需要分段进行传输，这时候需要设置transfer-encoding = chunked，否则不进行设置。

最后发送请求：

1 2	scss复制代码// 发送请求 channel.write(request);

在server端，我们同样需要构造一个HttpDataFactory，然后使用这个factory来构造一个HttpPostRequestDecoder，来对encoder出来的数据进行decode：

ini复制代码HttpDataFactory factory =
            new DefaultHttpDataFactory(DefaultHttpDataFactory.MINSIZE);
//POST请求
decoder = new HttpPostRequestDecoder(factory, request);

因为server端收到的消息根据发送消息的长度可以能是HttpContent，也可能是LastHttpContent。如果是HttpContent，我们将解析的结果放到一个StringBuilder中缓存起来，等接收到LastHttpContent再一起发送出去即可。

在收到HttpContent之后，我们调用decoder.offer方法，对HttpContent进行解码：

1	ini复制代码decoder.offer(chunk);

在decoder内部有两个存储HttpData数据的容器，分别是：

1
2
3

swift复制代码List<InterfaceHttpData> bodyListHttpData
和
Map<String, List<InterfaceHttpData>> bodyMapHttpData

decoder.offer就是对chunk进行解析，然后将解析过后的数据填充到bodyListHttpData和bodyMapHttpData中。

解析过后，就可以对解析过后的数据进行读取了。

可以通过decoder的hasNext和next方法对bodyListHttpData进行遍历，从而获取到对应的InterfaceHttpData。

通过data.getHttpDataType()可以拿到InterfaceHttpData的数据类型，上面也讲过了有Attribute和FileUpload两种类型。

POST方法上传文件

如果要POST文件，客户端在创建HttpPostRequestEncoder的时候传入multipart=true即可：

1 2	ini复制代码 HttpPostRequestEncoder bodyRequestEncoder = new HttpPostRequestEncoder(factory, request, true);

然后分别调用setBodyHttpDatas和finalizeRequest方法，生成HttpRequest就可以向channel写入了：

scss复制代码// 添加body http data
        bodyRequestEncoder.setBodyHttpDatas(bodylist);
        // finalize request，判断是否需要chunk
        request = bodyRequestEncoder.finalizeRequest();
        // 发送请求头
        channel.write(request);

要注意，如果是transfer-encoding = chunked，那么这个HttpRequest只是请求头的信息，我们还需要手动将HttpContent写入到channel中：

scss复制代码        // 判断bodyRequestEncoder是否是Chunked，发送请求内容
        if (bodyRequestEncoder.isChunked()) {
            channel.write(bodyRequestEncoder);
        }

在server端，通过判断InterfaceHttpData的getHttpDataType，如果是FileUpload类型，则说明拿到了上传的文件，则可以通过下面的方法来读取到文件的内容：

1 2	ini复制代码FileUpload fileUpload = (FileUpload) data; responseContent.append(fileUpload.getString(fileUpload.getCharset()));

这样我们就可以在服务器端拿到客户端传过来的文件了。

总结

HTTP的文件上传需要考虑的问题比较多，大家有不明白的可以参考我的例子。或者留言给我一起讨论。

本文的例子可以参考：learn-netty4

本文已收录于 www.flydean.com/21-netty-ht…

最通俗的解读，最深刻的干货，最简洁的教程，众多你不知道的小技巧等你来发现！

欢迎关注我的公众号:「程序那些事」,懂技术，更懂你！

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

MySQL中timestamp和datetime，你用的对么

发表于 2021-08-31

这是我参与8月更文挑战的第 31 天，活动详情查看：8月更文挑战

在MySQL中，时间是咱们用到最多的类型，建表时，对于时间字段类型的选择，你是如何选择的呢？有人会说timestamp，也有人会说datetime，那么我们到底如何选择呢，它们又有什么区别？今天就和大家一起来看看。

一、MySQL中如何表示当前时间？

其实，表达方式还是蛮多的，汇总如下：

CURRENT_TIMESTAMP

CURRENT_TIMESTAMP()

NOW()

LOCALTIME

LOCALTIME()

LOCALTIMESTAMP

LOCALTIMESTAMP()

二、关于TIMESTAMP和DATETIME的比较

一个完整的日期格式如下：YYYY-MM-DD HH:MM:SS[.fraction]，它可分为两部分：date部分和time部分，其中，date部分对应格式中的“YYYY-MM-DD”，time部分对应格式中的“HH:MM:SS[.fraction]”。对于date字段来说，它只支持date部分，如果插入了time部分的内容，它会丢弃掉该部分的内容，并提示一个warning。

如下所示：

sql复制代码mysql> create table test(id int,hiredate date);
Query OK, 0 rows affected (0.01 sec)
mysql> insert into test values(1,'20151208000000');
Query OK, 1 row affected (0.00 sec)
mysql> insert into test values(1,'20151208104400');
Query OK, 1 row affected, 1 warning (0.01 sec)
mysql> select * from test;
+------+------------+
| id   | hiredate   |
+------+------------+
|    1 | 2015-12-08 |
|    1 | 2015-12-08 |
+------+------------+
rows in set (0.00 sec)

注：第一个没提示warning的原因在于它的time部分都是0

TIMESTAMP和DATETIME的相同点：

两者都可用来表示YYYY-MM-DD HH:MM:SS[.fraction]类型的日期。

TIMESTAMP和DATETIME的不同点：

1> 两者的存储方式不一样

对于TIMESTAMP，它把客户端插入的时间从当前时区转化为UTC（世界标准时间）进行存储。查询时，将其又转化为客户端当前时区进行返回。

对于DATETIME，不做任何改变，基本上是原样输入和输出。

下面，我们来验证一下

首先创建两种测试表，一个使用timestamp格式，一个使用datetime格式。

sql复制代码mysql> create table test(id int,hiredate timestamp);
Query OK, 0 rows affected (0.01 sec)
mysql> insert into test values(1,'20151208000000');
Query OK, 1 row affected (0.00 sec)
mysql> create table test1(id int,hiredate datetime);
Query OK, 0 rows affected (0.01 sec)
mysql> insert into test1 values(1,'20151208000000');
Query OK, 1 row affected (0.00 sec)
mysql> select * from test;
+------+---------------------+
| id   | hiredate            |
+------+---------------------+
|    1 | 2015-12-08 00:00:00 |
+------+---------------------+
row in set (0.01 sec)
mysql> select * from test1;
+------+---------------------+
| id   | hiredate            |
+------+---------------------+
|    1 | 2015-12-08 00:00:00 |
+------+---------------------+
row in set (0.00 sec)

两者输出是一样的。

其次修改当前会话的时区

sql复制代码mysql> show variables like '%time_zone%'; 
+------------------+--------+
| Variable_name    | Value  |
+------------------+--------+
| system_time_zone | CST    |
| time_zone        | SYSTEM |
+------------------+--------+
rows in set (0.00 sec)
mysql> set time_zone='+0:00';
Query OK, 0 rows affected (0.00 sec)
mysql> select * from test;
+------+---------------------+
| id   | hiredate            |
+------+---------------------+
|    1 | 2015-12-07 16:00:00 |
+------+---------------------+
row in set (0.00 sec)
mysql> select * from test1;
+------+---------------------+
| id   | hiredate            |
+------+---------------------+
|    1 | 2015-12-08 00:00:00 |
+------+---------------------+
row in set (0.01 sec)

上述“CST”指的是MySQL所在主机的系统时间，是中国标准时间的缩写，China Standard Time UT+8:00。通过结果可以看出，test中返回的时间提前了8个小时，而test1中时间则不变。这充分验证了两者的区别。

2> 两者所能存储的时间范围不一样

timestamp所能存储的时间范围为：’1970-01-01 00:00:01.000000’ 到 ‘2038-01-19 03:14:07.999999’。

datetime所能存储的时间范围为：’1000-01-01 00:00:00.000000’ 到 ‘9999-12-31 23:59:59.999999’。

总结：TIMESTAMP和DATETIME除了存储范围和存储方式不一样，没有太大区别。当然，对于跨时区的业务，TIMESTAMP更为合适。

三、关于TIMESTAMP和DATETIME的自动初始化和更新

首先，我们先看一下下面的操作

sql复制代码mysql> create table test(id int,hiredate timestamp);
Query OK, 0 rows affected (0.01 sec)
 
 
mysql> insert into test(id) values(1);
Query OK, 1 row affected (0.00 sec)
 
 
mysql> select * from test;
+------+---------------------+
| id   | hiredate            |
+------+---------------------+
|    1 | 2015-12-08 14:34:46 |
+------+---------------------+
row in set (0.00 sec)
mysql> show create table test\G
*************************** 1. row ***************************
       Table: test
Create Table: CREATE TABLE `test` (
  `id` int(11) DEFAULT NULL,
  `hiredate` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=latin1
row in set (0.00 sec)

看起来是不是有点奇怪，我并没有对hiredate字段进行插入操作，它的值自动修改为当前值，而且在创建表的时候，我也并没有定义“show create table test\G”结果中显示的“DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP”。

其实，这个特性是自动初始化和自动更新（Automatic Initialization and Updating）。自动初始化指的是如果对该字段（譬如上例中的hiredate字段）没有显性赋值，则自动设置为当前系统时间。

自动更新指的是如果修改了其它字段，则该字段的值将自动更新为当前系统时间。它与“explicit_defaults_for_timestamp”参数有关。

默认情况下，该参数的值为OFF，如下所示：

sql复制代码mysql> show variables like '%explicit_defaults_for_timestamp%';
+---------------------------------+-------+
| Variable_name                   | Value |
+---------------------------------+-------+
| explicit_defaults_for_timestamp | OFF   |
+---------------------------------+-------+
row in set (0.00 sec)

下面我们看看官档的说明：

By default, the first TIMESTAMP column has both DEFAULT CURRENT_TIMESTAMP and ON UPDATE CURRENT_TIMESTAMP if neither is specified explicitly。

很多时候，这并不是我们想要的，如何禁用呢？

将“explicit_defaults_for_timestamp”的值设置为ON。

“explicit_defaults_for_timestamp”的值依旧是OFF，也有两种方法可以禁用

1> 用DEFAULT子句该该列指定一个默认值

2> 为该列指定NULL属性。

如下所示：

sql复制代码mysql> create table test1(id int,hiredate timestamp null);
Query OK, 0 rows affected (0.01 sec)
 
 
mysql> show create table test1\G
*************************** 1. row ***************************
       Table: test1
Create Table: CREATE TABLE `test1` (
  `id` int(11) DEFAULT NULL,
  `hiredate` timestamp NULL DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1
row in set (0.00 sec)
mysql> create table test2(id int,hiredate timestamp default 0);
Query OK, 0 rows affected (0.01 sec)
mysql> show create table test2\G
*************************** 1. row ***************************
       Table: test2
Create Table: CREATE TABLE `test2` (
  `id` int(11) DEFAULT NULL,
  `hiredate` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00'
) ENGINE=InnoDB DEFAULT CHARSET=latin1
row in set (0.00 sec)

在MySQL 5.6.5版本之前，Automatic Initialization and Updating只适用于TIMESTAMP，而且一张表中，最多允许一个TIMESTAMP字段采用该特性。从MySQL 5.6.5开始，Automatic Initialization and Updating同时适用于TIMESTAMP和DATETIME，且不限制数量。

参考：

dev.mysql.com/doc/refman/…

dev.mysql.com/doc/refman/…

www.2cto.com/database/20…

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

python实现两台不同主机之间进行通信（客户端和服务端）—

发表于 2021-08-31

这是我参与8月更文挑战的第31天，活动详情查看： 8月更文挑战

大家好，我是辰哥~

今天教大家通过Python进行Socket网络编程

（做一个聊天程序）

可以实现在不同的主机（电脑）之间进行通话。

具体效果如何，接着往下看

可以看到客户端（上方）向服务器端（下方）发送了内容，服务器端进行了回复

【备注：客户端是我的本机，服务器是另一条主机（阿里云服务器）】

两台主机的目的：验证两台主机可以相互通信

socket

 先简单给大家介绍一下什么是socket，socket(简称 套接字) 是进程间通信的一种方式，它与其他进程间通信的一个主要不同是：它能实现不同主机间的进程间通信。


 我们网络上各种各样的服务大多都是基于 Socket 来完成通信的，例如浏览网页、QQ 聊天、收发 email 等等


简单的说：socket可以实现不同主机间进行通信

socket通信的条件：IP和端口

ip相信大家都陌生了，每一台主机都有一个ip，不同主机之间通信的首要前提就是ip可以互访，此外还有一个条件就是端口，比如我们经常听到的80端口，3306端口，8080端口等。


主机中的数据是通过端口发送和接收，需要将对应端口打开才能进行通信。

形象比喻

ip相当于家庭地址，端口相当于门或者窗户

例子：

（主机A）快递员要想将快递（数据）送到你手中（另一台主机B）,需要知道你家的地址（主机B的ip），到你家门口后，需要你打开门（主机B的端口）才能拿到快递（数据）。

这里需要分服务端和客户端，客户端发送（主机A），服务器接收（主机B），当然了，每一台主机可以充当两个角色（既是客户端，也是服务器），这样就可以实现两台主机之间相互发送和接收。

看到这里之后，相信大家都清楚socket在实现不同主机之间通信的大概意思了，下面开始Python代码实现。

客户端实现过程

先来分析客户端（主机A）的实现过程

python复制代码from socket import *
# 1.创建套接字
tcp_socket = socket(AF_INET,SOCK_STREAM)
# 2.准备连接服务器，建立连接
serve_ip = "服务器端（主机B）的IP"
serve_port = 8000  #端口，比如8000
tcp_socket.connect((serve_ip,serve_port))  # 连接服务器，建立连接,参数是元组形式

首先与服务器接收端（主机B）建立连接，连接条件（主机B的ip和端口），这里的端口8000是指将数据发送到主机B的端口（主机B到时候会监听8000端口，然后进行接收数据）

python复制代码#准备需要传送的数据
send_data = "今天是2021年08月29日，辰哥给服务器端发送数据了"
tcp_socket.send(send_data.encode("gbk")) 
#从服务器接收数据
#注意这个1024byte，大小根据需求自己设置
from_server_msg = tcp_socket.recv(1024)
#加上.decode("gbk")可以解决乱码
print(from_server_msg.decode("gbk"))  
#关闭连接
tcp_socket.close()

send_data是往服务器端（主机B）发送的内容，from_server_msg是服务器端（主机B）往客户端（主机A）发送的内容

客户端的代码就结束了

服务器实现过程

分析服务器端（主机B）的实现过程

python复制代码from socket import  *
#创建套接字
tcp_server = socket(AF_INET,SOCK_STREAM)
#绑定ip，port
#这里ip默认本机
address = ('',8000)
tcp_server.bind(address)
# 启动被动连接
#多少个客户端可以连接
tcp_server.listen(128)  
#使用socket创建的套接字默认的属性是主动的
#使用listen将其变为被动的，这样就可以接收别人的链接了

服务器端（主机B）ip可以留空（默认本机），端口8000（因为客户端往8000端口发送数据，所以服务器需要监听的端口也是8000，与客户端的端口一致）

1
2
3

python复制代码# 创建接收
# 如果有新的客户端来链接服务器，那么就产生一个新的套接字专门为这个客户端服务
client_socket, clientAddr = tcp_server.accept()

python复制代码client_socket用来为这个客户端服务，相当于的tcp_server套接字的代理
tcp_server_socket就可以省下来专门等待其他新客户端的链接
这里clientAddr存放的就是连接服务器的客户端地址
#接收对方发送过来的数据
from_client_msg = client_socket.recv(1024)#接收1024给字节,这里recv接收的不再是元组，区别UDP
print("接收的数据：",from_client_msg.encode("gbk"))
#发送数据给客户端
send_data = client_socket.send("客户端你好，服务器端收到，公众号【Python研究者】".encode("gbk"))
#关闭套接字
#关闭为这个客户端服务的套接字，就意味着为不能再为这个客户端服务了
#如果还需要服务，只能再次重新连
client_socket.close()

from_client_msgs 是服务器端（主机B）接收到来自客户端（主机A）发送过来的数据send_data 是服务器端（主机B）往客户端（主机A）发送过去的数据

服务器端的代码就结束了

提醒：服务器端的8000端口需要开启，不然无法进行通信

演示

先启动（执行）服务器端（主机B）的程序，再执行客户端（主机A）

可以看到客户端（上方）向服务器端（下方）发送了内容，服务器端进行了回复

发送和响应内容：

客户端发送：今天是2021年08月29日，辰哥给服务器端发送数据了

服务器端接收并回复给客户端：客户端你好，服务器端收到，公众号【Python研究者】

实现持续通信过程

上方动图演示的是客户端和服务端的一次通信过程，可以将客户端的发送和服务端的接收放到循环中，实现持续通信过程。

客户端

python复制代码while(1):
    send_data = input("请输入内容：")
    #send_data = "今天是2021年08月29日，辰哥给服务器端发送数据了"
    tcp_socket.send(send_data.encode("gbk"))
    if send_data == "exit":
         break;
    #从服务器接收数据
    #注意这个1024byte，大小根据需求自己设置
    from_server_msg = tcp_socket.recv(1024)
    #加上.decode("gbk")可以解决乱码
    print(from_server_msg.decode("gbk"))
#关闭连接
tcp_socket.close()

服务端

python复制代码
while(1):
    #接收对方发送过来的数据
    from_client_msg = client_socket.recv(1024)#接收1024给字节,这里recv接收的不再是元组，区别UDP
    if(from_client_msg=="exit"):
        break
    print("接收的数据：",from_client_msg.decode("gbk"))
    now_time = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))
    #发送数据给客户端
    send_data = client_socket.send((str(now_time)+" 服务端：客户端你好，服务器端收到，公众号【Python研究者】").encode("gbk"))
    #关闭套接字
    #关闭为这个客户端服务的套接字，就意味着为不能再为这个客户端服务了
    #如果还需要服务，只能再次重新连
client_socket.close()

客户端可以持续给服务端发送数据，服务器接收数据后打印并返回数据给客户端

服务端返回的内容：

当前系统时间+服务端：客户端你好，服务器端收到，公众号【Python研究者】

最后当客户端输入：exit，则断开与服务端的连接

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

轮询锁在使用时遇到的问题与解决方案！

发表于 2021-08-31

这是我参与8月更文挑战的第8天，活动详情查看：8月更文挑战

当我们遇到死锁之后，除了可以手动重启程序解决之外，还可以考虑是使用顺序锁和轮询锁，这部分的内容可以参考我的上一篇文章，这里就不再赘述了。然而，轮询锁在使用的过程中，如果使用不当会带来新的严重问题，所以本篇我们就来了解一下这些问题，以及相应的解决方案。

问题演示

当我们没有使用轮询锁之前，可能会出现这样的问题：

java复制代码import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DeadLockByReentrantLock {
    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 创建锁 A
        Lock lockB = new ReentrantLock(); // 创建锁 B

        // 创建线程 1
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockA.lock(); // 加锁
                System.out.println("线程 1:获取到锁 A!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 1:等待获取 B...");
                    lockB.lock(); // 加锁
                    try {
                        System.out.println("线程 1:获取到锁 B!");
                    } finally {
                        lockA.unlock(); // 释放锁
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 释放锁
                }
            }
        });
        t1.start(); // 运行线程

        // 创建线程 2
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockB.lock(); // 加锁
                System.out.println("线程 2:获取到锁 B!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 2:等待获取 A...");
                    lockA.lock(); // 加锁
                    try {
                        System.out.println("线程 2:获取到锁 A!");
                    } finally {
                        lockA.unlock(); // 释放锁
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockB.unlock(); // 释放锁
                }
            }
        });
        t2.start(); // 运行线程
    }
}

以上代码的执行结果如下：

从上述结果可以看出，此时程序中出现了线程相互等待，并尝试获取对方（锁）资源的情况，这就是典型的死锁问题了。

简易版轮询锁

当出现死锁问题之后，我们就可以使用轮询锁来解决它了，它的实现思路是通过轮询的方式来获取多个锁，如果中途有任意一个锁获取失败，则执行回退操作，释放当前线程拥有的所有锁，等待下一次重新执行，这样就可以避免多个线程同时拥有并霸占锁资源了，从而直接解决了死锁的问题，简易版的轮询锁实现如下：

java复制代码import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SolveDeadLockExample2 {
    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 创建锁 A
        Lock lockB = new ReentrantLock(); // 创建锁 B

        // 创建线程 1(使用轮询锁)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 调用轮询锁
                pollingLock(lockA, lockB);
            }
        });
        t1.start(); // 运行线程

        // 创建线程 2
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockB.lock(); // 加锁
                System.out.println("线程 2:获取到锁 B!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 2:等待获取 A...");
                    lockA.lock(); // 加锁
                    try {
                        System.out.println("线程 2:获取到锁 A!");
                    } finally {
                        lockA.unlock(); // 释放锁
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockB.unlock(); // 释放锁
                }
            }
        });
        t2.start(); // 运行线程
    }

    /**
     * 轮询锁
     */
    private static void pollingLock(Lock lockA, Lock lockB) {
        // 轮询锁
        while (true) {
            if (lockA.tryLock()) { // 尝试获取锁
                System.out.println("线程 1:获取到锁 A!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 1:等待获取 B...");
                    if (lockB.tryLock()) { // 尝试获取锁
                        try {
                            System.out.println("线程 1:获取到锁 B!");
                        } finally {
                            lockB.unlock(); // 释放锁
                            System.out.println("线程 1:释放锁 B.");
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 释放锁
                    System.out.println("线程 1:释放锁 A.");
                }
            }
            // 等待一秒再继续执行
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

以上代码的执行结果如下：

从上述结果可以看出，当我们在程序中使用轮询锁之后就不会出现死锁的问题了，但以上轮询锁也并不是完美无缺的，下面我们来看看这个轮询锁会有什么样的问题？

问题1：死循环

以上简易版的轮询锁，如果遇到有一个线程一直霸占或者长时间霸占锁资源的情况，就会导致这个轮询锁进入死循环的状态，它会尝试一直获取锁资源，这样就会造成新的问题，带来不必要的性能开销，具体示例如下。

反例

java复制代码import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SolveDeadLockExample {

    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 创建锁 A
        Lock lockB = new ReentrantLock(); // 创建锁 B

        // 创建线程 1(使用轮询锁)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 调用轮询锁
                pollingLock(lockA, lockB);
            }
        });
        t1.start(); // 运行线程

        // 创建线程 2
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockB.lock(); // 加锁
                System.out.println("线程 2:获取到锁 B!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 2:等待获取 A...");
                    lockA.lock(); // 加锁
                    try {
                        System.out.println("线程 2:获取到锁 A!");
                    } finally {
                        lockA.unlock(); // 释放锁
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 如果此处代码未执行，线程 2 一直未释放锁资源
                    // lockB.unlock(); 
                }
            }
        });
        t2.start(); // 运行线程
    }

    /**
     * 轮询锁
     */
    public static void pollingLock(Lock lockA, Lock lockB) {
        while (true) {
            if (lockA.tryLock()) { // 尝试获取锁
                System.out.println("线程 1:获取到锁 A!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 1:等待获取 B...");
                    if (lockB.tryLock()) { // 尝试获取锁
                        try {
                            System.out.println("线程 1:获取到锁 B!");
                        } finally {
                            lockB.unlock(); // 释放锁
                            System.out.println("线程 1:释放锁 B.");
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 释放锁
                    System.out.println("线程 1:释放锁 A.");
                }
            }
            // 等待一秒再继续执行
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

以上代码的执行结果如下：

从上述结果可以看出，线程 1 轮询锁进入了死循环的状态。

优化版

针对以上死循环的情况，我们可以改进的思路有以下两种：

添加最大次数限制：如果经过了 n 次尝试获取锁之后，还未获取到锁，则认为获取锁失败，执行失败策略之后终止轮询（失败策略可以是记录日志或其他操作）；
添加最大时长限制：如果经过了 n 秒尝试获取锁之后，还未获取到锁，则认为获取锁失败，执行失败策略之后终止轮询。

以上策略任选其一就可以解决死循环的问题，出于实现成本的考虑，我们可以采用轮询最大次数的方式来改进轮询锁，具体实现代码如下：

java复制代码import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SolveDeadLockExample {

    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 创建锁 A
        Lock lockB = new ReentrantLock(); // 创建锁 B

        // 创建线程 1(使用轮询锁)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 调用轮询锁
                pollingLock(lockA, lockB, 3);
            }
        });
        t1.start(); // 运行线程

        // 创建线程 2
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockB.lock(); // 加锁
                System.out.println("线程 2:获取到锁 B!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 2:等待获取 A...");
                    lockA.lock(); // 加锁
                    try {
                        System.out.println("线程 2:获取到锁 A!");
                    } finally {
                        lockA.unlock(); // 释放锁
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 线程 2 忘记释放锁资源
                    // lockB.unlock(); // 释放锁
                }
            }
        });
        t2.start(); // 运行线程
    }

    /**
     * 轮询锁
     *
     * maxCount：最大轮询次数
     */
    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
        // 轮询次数计数器
        int count = 0;
        while (true) {
            if (lockA.tryLock()) { // 尝试获取锁
                System.out.println("线程 1:获取到锁 A!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 1:等待获取 B...");
                    if (lockB.tryLock()) { // 尝试获取锁
                        try {
                            System.out.println("线程 1:获取到锁 B!");
                        } finally {
                            lockB.unlock(); // 释放锁
                            System.out.println("线程 1:释放锁 B.");
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 释放锁
                    System.out.println("线程 1:释放锁 A.");
                }
            }

            // 判断是否已经超过最大次数限制
            if (count++ > maxCount) {
                // 终止循环
                System.out.println("轮询锁获取失败,记录日志或执行其他失败策略");
                return;
            }

            // 等待一秒再继续尝试获取锁
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

以上代码的执行结果如下：

从以上结果可以看出，当我们改进之后，轮询锁就不会出现死循环的问题了，它会尝试一定次数之后终止执行。

问题2：线程饿死

我们以上的轮询锁的轮询等待时间是固定时间，如下代码所示：

java复制代码// 等待 1s 再尝试获取（轮询）锁
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}

这样在特殊情况下会造成线程饿死的问题，也就是轮询锁一直获取不到锁的问题，比如以下示例。

反例

java复制代码import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SolveDeadLockExample {

    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 创建锁 A
        Lock lockB = new ReentrantLock(); // 创建锁 B

        // 创建线程 1(使用轮询锁)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 调用轮询锁
                pollingLock(lockA, lockB, 3);
            }
        });
        t1.start(); // 运行线程

        // 创建线程 2
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    lockB.lock(); // 加锁
                    System.out.println("线程 2:获取到锁 B!");
                    try {
                        System.out.println("线程 2:等待获取 A...");
                        lockA.lock(); // 加锁
                        try {
                            System.out.println("线程 2:获取到锁 A!");
                        } finally {
                            lockA.unlock(); // 释放锁
                        }
                    } finally {
                        lockB.unlock(); // 释放锁
                    }
                    // 等待一秒之后继续执行
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t2.start(); // 运行线程
    }

    /**
     * 轮询锁
     */
    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
        // 循环次数计数器
        int count = 0;
        while (true) {
            if (lockA.tryLock()) { // 尝试获取锁
                System.out.println("线程 1:获取到锁 A!");
                try {
                    Thread.sleep(100); // 等待 0.1s(获取锁需要的时间)
                    System.out.println("线程 1:等待获取 B...");
                    if (lockB.tryLock()) { // 尝试获取锁
                        try {
                            System.out.println("线程 1:获取到锁 B!");
                        } finally {
                            lockB.unlock(); // 释放锁
                            System.out.println("线程 1:释放锁 B.");
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 释放锁
                    System.out.println("线程 1:释放锁 A.");
                }
            }

            // 判断是否已经超过最大次数限制
            if (count++ > maxCount) {
                // 终止循环
                System.out.println("轮询锁获取失败,记录日志或执行其他失败策略");
                return;
            }

            // 等待一秒再继续尝试获取锁
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

以上代码的执行结果如下：

从上述结果可以看出，线程 1（轮询锁）一直未成功获取到锁，造成这种结果的原因是：线程 1 每次轮询的等待时间为固定的 1s，而线程 2 也是相同的频率，每 1s 获取一次锁，这样就会导致线程 2 会一直先成功获取到锁，而线程 1 则会一直处于“饿死”的情况，执行流程如下图所示：

优化版

接下来，我们可以将轮询锁的固定等待时间，改进为固定时间 + 随机时间的方式，这样就可以避免因为获取锁的频率一致，而造成轮询锁“饿死”的问题了，具体实现代码如下：

java复制代码import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SolveDeadLockExample {
    private static Random rdm = new Random();

    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 创建锁 A
        Lock lockB = new ReentrantLock(); // 创建锁 B

        // 创建线程 1(使用轮询锁)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 调用轮询锁
                pollingLock(lockA, lockB, 3);
            }
        });
        t1.start(); // 运行线程

        // 创建线程 2
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    lockB.lock(); // 加锁
                    System.out.println("线程 2:获取到锁 B!");
                    try {
                        System.out.println("线程 2:等待获取 A...");
                        lockA.lock(); // 加锁
                        try {
                            System.out.println("线程 2:获取到锁 A!");
                        } finally {
                            lockA.unlock(); // 释放锁
                        }
                    } finally {
                        lockB.unlock(); // 释放锁
                    }
                    // 等待一秒之后继续执行
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t2.start(); // 运行线程
    }

    /**
     * 轮询锁
     */
    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
        // 循环次数计数器
        int count = 0;
        while (true) {
            if (lockA.tryLock()) { // 尝试获取锁
                System.out.println("线程 1:获取到锁 A!");
                try {
                    Thread.sleep(100); // 等待 0.1s(获取锁需要的时间)
                    System.out.println("线程 1:等待获取 B...");
                    if (lockB.tryLock()) { // 尝试获取锁
                        try {
                            System.out.println("线程 1:获取到锁 B!");
                        } finally {
                            lockB.unlock(); // 释放锁
                            System.out.println("线程 1:释放锁 B.");
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 释放锁
                    System.out.println("线程 1:释放锁 A.");
                }
            }

            // 判断是否已经超过最大次数限制
            if (count++ > maxCount) {
                // 终止循环
                System.out.println("轮询锁获取失败,记录日志或执行其他失败策略");
                return;
            }

            // 等待一定时间(固定时间 + 随机时间)之后再继续尝试获取锁
            try {
                Thread.sleep(300 + rdm.nextInt(8) * 100); // 固定时间 + 随机时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

以上代码的执行结果如下：

从上述结果可以看出，线程 1（轮询锁）加入随机等待时间之后就不会出现线程饿死的问题了。

总结

本文我们介绍了轮询锁的用途，用于解决死锁问题，但简易版的轮询锁在某些情况下会造成死循环和线程饿死的问题，因此我们对轮询锁进行了优化，给轮询锁加入了最大轮询次数，以及随机轮询等待时间，这样就可以解决因为引入轮询锁而造成的新问题了，这样就可以愉快的使用它来解决死锁的问题了。

参考 & 鸣谢

《Java并发编程实战》

并发原创文章推荐

关注公号「Java中文社群」查看更多有意思、涨知识的 Java 并发文章。

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

spring-data-redis 动态切换数据源

发表于 2021-08-31

这是我参与8月更文挑战的第31天，活动详情查看：8月更文挑战

最近遇到了一个麻烦的需求，我们需要一个微服务应用同时访问两个不同的 Redis 集群。一般我们不会这么使用 Redis，但是这两个 Redis 本来是不同业务集群，现在需要一个微服务同时访问。

其实我们在实际业务开发的时候，可能还会遇到类似的场景。例如 Redis 读写分离，这个也是 spring-data-redis 没有提供的功能，底层连接池例如 Lettuce 或者 Jedis 都提供了获取只读连接的 API，但是缺陷有两个：

上层 spring-data-redis 并没有封装这种接口
基于 redis 的架构实现的，哨兵模式需要配置 sentinel 的地址，集群模式需要感知集群拓扑，在云原生环境中，这些都默认被云提供商隐藏了，暴露到外面的只有一个个动态 VIP 域名。

因此，我们需要在 spring-data-redis 的基础上实现一个动态切换 Redis 连接的机制。

spring-data-redis 的配置类为：org.springframework.boot.autoconfigure.data.redis.RedisProperties，可以配置单个 Redis 实例或者 Redis 集群的连接配置。根据这些配置，会生成统一的 Redis 连接工厂 RedisConnectionFactory

spring-data-redis 核心接口与背后的连接相关抽象关系为：

通过这个图，我们可以知道，我们实现一个可以动态返回不同 Redis 连接的 RedisConnectionFactory 即可，并且根据 spring-data-redis 的自动装载源码可以知道，框架内的所有 RedisConnectionFactory 是 @ConditionalOnMissingBean 的，即我们可以使用我们自己实现的 RedisConnectionFactory 进行替换。

项目地址：github.com/JoJoTec/spr…

我们可以给 RedisProperties 配置外层封装一个多 Redis 连接的配置，即MultiRedisProperties：

java复制代码@Data
@NoArgsConstructor
@ConfigurationProperties(prefix = "spring.redis")
public class MultiRedisProperties {
    /**
     * 默认连接必须配置，配置 key 为 default
     */
    public static final String DEFAULT = "default";

    private boolean enableMulti = false;
    private Map<String, RedisProperties> multi;
}

这个配置是在原有配置基础上的，也就是用户可以使用原有配置，也可以使用这种多 Redis 配置，就是需要配置 spring.redis.enable-multi=true。multi 这个 Map 中放入的 key 是数据源名称，用户可以在使用 RedisTemplate 或者 ReactiveRedisTemplate 之前，通过这个数据源名称指定用哪个 Redis。

接下来我们来实现 MultiRedisLettuceConnectionFactory，即可以动态切换 Redis 连接的 RedisConnectionFactory，我们的项目采用的 Redis 客户端是 Lettuce：

java复制代码public class MultiRedisLettuceConnectionFactory
        implements InitializingBean, DisposableBean, RedisConnectionFactory, ReactiveRedisConnectionFactory {
    private final Map<String, LettuceConnectionFactory> connectionFactoryMap;

    private static final ThreadLocal<String> currentRedis = new ThreadLocal<>();

    public MultiRedisLettuceConnectionFactory(Map<String, LettuceConnectionFactory> connectionFactoryMap) {
        this.connectionFactoryMap = connectionFactoryMap;
    }

    public void setCurrentRedis(String currentRedis) {
        if (!connectionFactoryMap.containsKey(currentRedis)) {
            throw new RedisRelatedException("invalid currentRedis: " + currentRedis + ", it does not exists in configuration");
        }
        MultiRedisLettuceConnectionFactory.currentRedis.set(currentRedis);
    }

    @Override
    public void destroy() throws Exception {
        connectionFactoryMap.values().forEach(LettuceConnectionFactory::destroy);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        connectionFactoryMap.values().forEach(LettuceConnectionFactory::afterPropertiesSet);
    }

    private LettuceConnectionFactory currentLettuceConnectionFactory() {
        String currentRedis = MultiRedisLettuceConnectionFactory.currentRedis.get();
        if (StringUtils.isNotBlank(currentRedis)) {
            MultiRedisLettuceConnectionFactory.currentRedis.remove();
            return connectionFactoryMap.get(currentRedis);
        }
        return connectionFactoryMap.get(MultiRedisProperties.DEFAULT);
    }

    @Override
    public ReactiveRedisConnection getReactiveConnection() {
        return currentLettuceConnectionFactory().getReactiveConnection();
    }

    @Override
    public ReactiveRedisClusterConnection getReactiveClusterConnection() {
        return currentLettuceConnectionFactory().getReactiveClusterConnection();
    }

    @Override
    public RedisConnection getConnection() {
        return currentLettuceConnectionFactory().getConnection();
    }

    @Override
    public RedisClusterConnection getClusterConnection() {
        return currentLettuceConnectionFactory().getClusterConnection();
    }

    @Override
    public boolean getConvertPipelineAndTxResults() {
        return currentLettuceConnectionFactory().getConvertPipelineAndTxResults();
    }

    @Override
    public RedisSentinelConnection getSentinelConnection() {
        return currentLettuceConnectionFactory().getSentinelConnection();
    }

    @Override
    public DataAccessException translateExceptionIfPossible(RuntimeException ex) {
        return currentLettuceConnectionFactory().translateExceptionIfPossible(ex);
    }
}

逻辑非常简单，就是提供了设置 Redis 数据源的接口，并且放入了 ThreadLocal 中，并且仅对当前一次有效，读取后就清空。

然后，将 MultiRedisLettuceConnectionFactory 作为 Bean 注册到我们的 ApplicationContext 中：

java复制代码@ConditionalOnProperty(prefix = "spring.redis", value = "enable-multi", matchIfMissing = false)
@Configuration(proxyBeanMethods = false)
public class RedisCustomizedConfiguration {

    /**
     * @param builderCustomizers
     * @param clientResources
     * @param multiRedisProperties
     * @return
     * @see org.springframework.boot.autoconfigure.data.redis.LettuceConnectionConfiguration
     */
    @Bean
    public MultiRedisLettuceConnectionFactory multiRedisLettuceConnectionFactory(
            ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers,
            ClientResources clientResources,
            MultiRedisProperties multiRedisProperties,
            ObjectProvider<RedisSentinelConfiguration> sentinelConfigurationProvider,
            ObjectProvider<RedisClusterConfiguration> clusterConfigurationProvider
    ) {
        //读取配置
        Map<String, LettuceConnectionFactory> connectionFactoryMap = Maps.newHashMap();
        Map<String, RedisProperties> multi = multiRedisProperties.getMulti();
        multi.forEach((k, v) -> {
            //这个其实就是框架中原有的源码使用 RedisProperties 的方式，我们其实就是在 RedisProperties 外面包装了一层而已
            LettuceConnectionConfiguration lettuceConnectionConfiguration = new LettuceConnectionConfiguration(
                    v,
                    sentinelConfigurationProvider,
                    clusterConfigurationProvider
            );
            LettuceConnectionFactory lettuceConnectionFactory = lettuceConnectionConfiguration.redisConnectionFactory(builderCustomizers, clientResources);
            connectionFactoryMap.put(k, lettuceConnectionFactory);
        });
        return new MultiRedisLettuceConnectionFactory(connectionFactoryMap);
    }

}

我们来测试下，使用 embedded-redis 来启动本地 redis，从而实现单元测试。我们启动两个 Redis，在两个 Redis 中放入不同的 Key，验证是否存在，并且测试同步接口，多线程调用同步接口，和多次异步接口无等待订阅从而测试有效性。：

java复制代码import com.github.jojotech.spring.boot.starter.redis.related.lettuce.MultiRedisLettuceConnectionFactory;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.ReactiveStringRedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import reactor.core.publisher.Mono;
import redis.embedded.RedisServer;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;

@ExtendWith(SpringExtension.class)
@SpringBootTest(properties = {
        "spring.redis.enable-multi=true",
        "spring.redis.multi.default.host=127.0.0.1",
        "spring.redis.multi.default.port=6379",
        "spring.redis.multi.test.host=127.0.0.1",
        "spring.redis.multi.test.port=6380",
})
public class MultiRedisTest {
    //启动两个 redis
    private static RedisServer redisServer;
    private static RedisServer redisServer2;

    @BeforeAll
    public static void setUp() throws Exception {
        System.out.println("start redis");
        redisServer = RedisServer.builder().port(6379).setting("maxheap 200m").build();
        redisServer2 = RedisServer.builder().port(6380).setting("maxheap 200m").build();
        redisServer.start();
        redisServer2.start();
        System.out.println("redis started");
    }

    @AfterAll
    public static void tearDown() throws Exception {
        System.out.println("stop redis");
        redisServer.stop();
        redisServer2.stop();
        System.out.println("redis stopped");
    }

    @EnableAutoConfiguration
    @Configuration
    public static class App {
    }

    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private ReactiveStringRedisTemplate reactiveRedisTemplate;
    @Autowired
    private MultiRedisLettuceConnectionFactory multiRedisLettuceConnectionFactory;

    private void testMulti(String suffix) {
        //使用默认连接，设置 "testDefault" + suffix, "testDefault" 键值对
        redisTemplate.opsForValue().set("testDefault" + suffix, "testDefault");
        //使用 test 连接，设置 "testSecond" + suffix, "testDefault" 键值对
        multiRedisLettuceConnectionFactory.setCurrentRedis("test");
        redisTemplate.opsForValue().set("testSecond" + suffix, "testSecond");
        //使用默认连接，验证 "testDefault" + suffix 存在，"testSecond" + suffix 不存在
        Assertions.assertTrue(redisTemplate.hasKey("testDefault" + suffix));
        Assertions.assertFalse(redisTemplate.hasKey("testSecond" + suffix));
        //使用 test 连接，验证 "testDefault" + suffix 不存在，"testSecond" + suffix 存在
        multiRedisLettuceConnectionFactory.setCurrentRedis("test");
        Assertions.assertFalse(redisTemplate.hasKey("testDefault" + suffix));
        multiRedisLettuceConnectionFactory.setCurrentRedis("test");
        Assertions.assertTrue(redisTemplate.hasKey("testSecond" + suffix));
    }

    //单次验证
    @Test
    public void testMultiBlock() {
        testMulti("");
    }

    //多线程验证
    @Test
    public void testMultiBlockMultiThread() throws InterruptedException {
        Thread thread[] = new Thread[50];
        AtomicBoolean result = new AtomicBoolean(true);
        for (int i = 0; i < thread.length; i++) {
            int finalI = i;
            thread[i] = new Thread(() -> {
                try {
                    testMulti("" + finalI);
                } catch (Exception e) {
                    e.printStackTrace();
                    result.set(false);
                }
            });
        }
        for (int i = 0; i < thread.length; i++) {
            thread[i].start();
        }
        for (int i = 0; i < thread.length; i++) {
            thread[i].join();
        }
        Assertions.assertTrue(result.get());
    }

    //reactive 接口验证
    private Mono<Boolean> reactiveMulti(String suffix) {
        return reactiveRedisTemplate.opsForValue().set("testReactiveDefault" + suffix, "testReactiveDefault")
                .flatMap(b -> {
                    multiRedisLettuceConnectionFactory.setCurrentRedis("test");
                    return reactiveRedisTemplate.opsForValue().set("testReactiveSecond" + suffix, "testReactiveSecond");
                }).flatMap(b -> {
                    return reactiveRedisTemplate.hasKey("testReactiveDefault" + suffix);
                }).map(b -> {
                    Assertions.assertTrue(b);
                    System.out.println(Thread.currentThread().getName());
                    return b;
                }).flatMap(b -> {
                    return reactiveRedisTemplate.hasKey("testReactiveSecond" + suffix);
                }).map(b -> {
                    Assertions.assertFalse(b);
                    System.out.println(Thread.currentThread().getName());
                    return b;
                }).flatMap(b -> {
                    multiRedisLettuceConnectionFactory.setCurrentRedis("test");
                    return reactiveRedisTemplate.hasKey("testReactiveDefault" + suffix);
                }).map(b -> {
                    Assertions.assertFalse(b);
                    System.out.println(Thread.currentThread().getName());
                    return b;
                }).flatMap(b -> {
                    multiRedisLettuceConnectionFactory.setCurrentRedis("test");
                    return reactiveRedisTemplate.hasKey("testReactiveSecond" + suffix);
                }).map(b -> {
                    Assertions.assertTrue(b);
                    return b;
                });
    }

    //多次调用 reactive 验证，并且 subscribe，这本身就是多线程的
    @Test
    public void testMultiReactive() throws InterruptedException {
        for (int i = 0; i < 10000; i++) {
            reactiveMulti("" + i).subscribe(System.out::println);
        }
        TimeUnit.SECONDS.sleep(10);
    }
}

运行测试，通过。

微信搜索“我的编程喵”关注公众号，每日一刷，轻松提升技术，斩获各种offer

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

❤️ 硬核！2021年，微软居然开源了 Linux ？不敢信

发表于 2021-08-31

这是我参与8月更文挑战的第31天，活动详情查看：8月更文挑战

🌲 前言

CBL 代表 Common Base Linux，Mariner 的目标是用作微软工程团队的内部 Linux 发行版，以构建云基础设施和边缘产品和服务。

在这里插入图片描述

☀️ 介绍

Mariner 是开源的，它在微软的 GitHub 组织下有自己的存储库。目前没有提供 Mariner 的 ISO 或映像，需要自行编译，但是 repo 有在 Ubuntu 18.04 上构建它们的说明。

文末有博主编译好的 ISO 文件，可以直接下载安装体验！

此GitHub 页面中列出了一系列先决条件，大致包括 Docker、RPM 工具、ISO 构建工具和 Golang 等。

官方源： github.com/pc-study/CB…

🍉 编译 CBL 镜像文件

❤️ 接下来，我们就本地编译一个镜像文件来玩玩！

编译环境准备

官方建议使用 ubuntu 18.04 版本进行编译，其他版本不知道是否可以！

vagrant 安装 ubuntu 18.04

由于需要在 Ubuntu 18.04 上进行构建，因此使用 vagrant 本地快速创建一台虚拟机环境。

bash复制代码mkdir -p /Volumes/DBA/vagrant/ubuntu1804
cd /Volumes/DBA/vagrant/ubuntu1804
vagrant init generic/ubuntu1804
vagrant up --provider=virtualbox

连接主机修改密码

1
2
3

bash复制代码vagrant ssh
sudo passwd root
su - root

先决条件配置

添加一个 backports 存储库以安装最新版本的 Go:

1 2	bash复制代码sudo add-apt-repository ppa:longsleep/golang-backports sudo apt-get update

1、安装所需的依赖项：

1	bash复制代码sudo apt -y install make tar wget curl rpm qemu-utils golang-1.15-go genisoimage python-minimal bison gawk parted

2、推荐安装 pigz ，但不是必须，用于更快的压缩操作：

1	bash复制代码sudo apt -y install pigz

3、修复 go 1.15 link：

1	bash复制代码sudo ln -vsf /usr/lib/go-1.15/bin/go /usr/bin/go

4、安装 docker：

1
2
3

bash复制代码curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER

配置完成后建议关闭主机：

1	bash复制代码vagrant halt

下载 CBL-Mariner 项目

由于官方源太慢，于是我 fork 到了我的 gitee 仓库：gitee.com/luciferlpc/…。

1	bash复制代码git clone https://gitee.com/luciferlpc/CBL-Mariner.git

下载到本地之后，上传到服务器主机中：

编辑 Vagrantfile 文件，挂载当前目录到主机 /vagrant 目录：

重新启动 Ubuntu 主机：

1 2	bash复制代码cd /Volumes/DBA/vagrant/ubuntu1804 vagrant up

或者通过 ftp 等工具进行上传！

同步到最新的稳定版本：

1	bash复制代码git checkout 1.0-stable

把文件拷贝到 /opt 目录下：

1	bash复制代码cp -r /vagrant/CBL-Mariner /opt

构建 VHD 或 VHDX 镜像

📢 注意：这里有个小问题，关于解析和GO：

修复：

bash复制代码export GO111MODULE=on
export GOPROXY=https://goproxy.io
echo '47.246.43.224 goproxy.cn' >>/etc/hosts
echo '140.82.121.3 github.com' >>/etc/hosts
echo 'nameserver 8.8.8.8' >>/etc/resolv.conf
echo 'nameserver 8.8.4.4' >>/etc/resolv.conf

构建 VHDX 镜像

镜像放在../out/images/core-efi：

1 2	bash复制代码cd toolkit sudo make image REBUILD_TOOLS=y REBUILD_PACKAGES=n CONFIG_FILE=./imageconfigs/core-efi.json

构建过程中，可能存在域名无法解析的问题，可以访问：packages.microsoft.com/cbl-mariner… rpm 包。

等待很久很久时间后，完成：

构建 VHD 镜像

镜像放在../out/images/core-legacy：

1 2	bash复制代码cd toolkit sudo make image REBUILD_TOOLS=y REBUILD_PACKAGES=n CONFIG_FILE=./imageconfigs/core-legacy.json

构建 cloud-init 配置镜像

镜像放在../out/images/meta-user-data.iso

1 2	bash复制代码cd toolkit sudo make meta-user-data

新建并访问主机

使用 virtualbox 创建 VHD(X) 虚拟机。

1、创建新主机

2、选择编译好的 VHD(X) 文件

3、挂载 Meta-User-Data.Iso 镜像

4、启动并登录虚拟机

账号密码：

1	css复制代码mariner_user/p@ssw0rd

总体来说，Linux 的命令都差不多。

构建 ISO 镜像

镜像放在../out/images/full

1 2	bash复制代码cd toolkit sudo make iso REBUILD_TOOLS=y REBUILD_PACKAGES=n CONFIG_FILE=./imageconfigs/full.json

生成的 ISO 镜像大概 700M 不到。

用 ISO 镜像安装系统

终端模式安装

1、创建新主机：

后面选项全都默认即可。

2、挂载上面生成的 ISO 镜像：

3、启动主机并安装：

选择安装模式：分为终端和图形化，本次选择终端安装。

选择完全安装：

选择系统安装盘：

跳过磁盘加密：

设置主机名：

创建用户和密码：密码规则要求较高。

开始安装：

安装完重启：

图形化模式安装

1、创建新主机：

后面选项全都默认即可。

2、挂载上面生成的 ISO 镜像：

3、启动主机并安装：

选择安装模式：分为终端和图形化，本次选择图形化安装。

选择完全安装：

选择接受协议：

不加密磁盘：

创建用户密码：

开始安装：

安装完重启：

重启后连接：

⭐️ 至此，CBL-Mariner 已经成功安装体验过！

❄️ 写在最后

如果不想自己编译 ISO 镜像的朋友，可以直接下载我编译好的镜像安装体验！

❤️ 可以扫码关注我公众号，菜单栏自取！❤️

Lucifer三思而后行

本次分享到此结束啦~

如果觉得文章对你有帮助，点赞、收藏、关注、评论，一键四连支持，你的支持就是我创作最大的动力。

❤️ 技术交流可以关注公众号：Lucifer三思而后行 ❤️

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

【Mybatis】Mybatis源码之懒加载原理时序图关

发表于 2021-08-30

这是我参与8月更文挑战的第30天，活动详情查看：8月更文挑战

嵌套查询与懒加载的代码实现这里不再赘述，见文章Mybatis之缓存、懒加载。下面我们来直接分析源码，看看懒加载的执行过程。

时序图

BaseExecutorSimpleExecutorPreparedStatementHandlerDefaultResultSetHandlerqueryqueryFromDatabasedoQueryqueryhandleResultSetshandleResultSethandleRowValueshandleRowValuesForSimpleResultMapgetRowValueapplyPropertyMappingsgetPropertyMappingValuegetPropertyMappingValueList

BaseExecutor#query

query方法，所有查询都需要经过这里，如果是普通查询，则进入查询时queryStack=1，查询结束后queryStack=0
如果是嵌套查询，进入嵌套外部查询时，queryStack=1，进入嵌套内部查询时，queryStack=2，嵌套内部查询结束后queryStack=1，嵌套外部查询结束后queryStack=0.

java复制代码/**
 * 查询数据库中的数据
 * @param ms 映射语句
 * @param parameter 参数对象
 * @param rowBounds 翻页限制条件
 * @param resultHandler 结果处理器
 * @param key 缓存的键
 * @param boundSql 查询语句
 * @param <E> 结果类型
 * @return 结果列表
 * @throws SQLException
 */
@SuppressWarnings("unchecked")
@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
    if (closed) {
        // 执行器已经关闭
        throw new ExecutorException("Executor was closed.");
    }
    if (queryStack == 0 && ms.isFlushCacheRequired()) { // 新的查询栈且要求清除缓存
        // 新的查询栈，故清除本地缓存，即清除一级缓存
        clearLocalCache();
    }
    List<E> list;
    try {
        /**
         * 查询栈，第一次进入时，压栈
         * 普通查询时，压栈后执行查询，完成后出栈，查询栈为0
         * 嵌套查询时，第一次进入后压栈，在第一次查询还未完成（查询栈未出栈）时执行嵌套查询，会再次压栈，因此就会出现查询栈大于1的情况
         */
        queryStack++;
        // 尝试从本地缓存获取结果
        list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
        if (list != null) {
            // 本地缓存中有结果，则对于CALLABLE语句还需要绑定到IN/INOUT参数上
            handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
        } else {
            // 本地缓存没有结果，故需要查询数据库
            list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
        }
    } finally {
        // 查询结束后，出栈
        queryStack--;
    }
    if (queryStack == 0) {
        // 懒加载操作的处理
        for (DeferredLoad deferredLoad : deferredLoads) {
            deferredLoad.load();
        }
        // issue #601
        deferredLoads.clear();
        // 如果本地缓存的作用域为STATEMENT，则立刻清除本地缓存
        if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
            // issue #482
            clearLocalCache();
        }
    }
    return list;
}

DefaultResultSetHandler#getRowValue

在getRowValue方法中，会先创建接收结果的空对象
判断是否开启自动映射，开启自动映射的配置及枚举如下

1	xml复制代码<setting name="autoMappingBehavior" value="PARTIAL"/>

java复制代码// 自动映射选项
public enum AutoMappingBehavior {

    /**
     * Disables auto-mapping.
     */
    // 关闭自动映射
    NONE,

    /**
     * Will only auto-map results with no nested result mappings defined inside.
     */
    // 仅仅自动映射单层属性
    PARTIAL,

    /**
     * Will auto-map result mappings of any complexity (containing nested or otherwise).
     */
    // 映射所有属性，含嵌套属性
    FULL
}

根据resultMap标签配置的映射关系进行映射

java复制代码/**
 * 将一条记录转化为一个对象
 *
 * @param rsw          结果集包装
 * @param resultMap    结果映射
 * @param columnPrefix 列前缀
 * @return 转化得到的对象
 * @throws SQLException
 */
private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap, String columnPrefix) throws SQLException {
    // 懒加载
    final ResultLoaderMap lazyLoader = new ResultLoaderMap();
    // 创建这一行记录对应的空对象
    Object rowValue = createResultObject(rsw, resultMap, lazyLoader, columnPrefix);
    if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
        // 根据对象得到其MetaObject
        final MetaObject metaObject = configuration.newMetaObject(rowValue);
        boolean foundValues = this.useConstructorMappings;
        // 是否允许自动映射未明示的字段
        if (shouldApplyAutomaticMappings(resultMap, false)) {
            // 自动映射未明示的字段(resultType)，映射时的TypeHandler通过属性名与set方法参数类型的映射来获取属性的类型，并据此获取对应的TypeHandler
            foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, columnPrefix) || foundValues;
        }
        // 按照明示的字段进行重新映射(resultMap)，解析XML时获取TypeHandler
        foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnPrefix) || foundValues;
        foundValues = lazyLoader.size() > 0 || foundValues;
        rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;
    }
    return rowValue;
}

DefaultResultSetHandler#createResultObject

在createResultObject方法中，会根据resultMap标签中的type属性来创建结果集的接收对象
如果当前属性是嵌套查询，并且是懒加载，则会创建接收对象的代理对象，代理类是EnhancedResultObjectProxyImpl

java复制代码private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap, ResultLoaderMap lazyLoader, String columnPrefix) throws SQLException {
    this.useConstructorMappings = false; // reset previous mapping result
    final List<Class<?>> constructorArgTypes = new ArrayList<>();
    final List<Object> constructorArgs = new ArrayList<>();
    Object resultObject = createResultObject(rsw, resultMap, constructorArgTypes, constructorArgs, columnPrefix);
    if (resultObject != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
        final List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();
        for (ResultMapping propertyMapping : propertyMappings) {
            // issue gcode #109 && issue #149
            // 如果是嵌套查询，并且是懒加载，则创建代理对象
            if (propertyMapping.getNestedQueryId() != null && propertyMapping.isLazy()) {
                resultObject = configuration.getProxyFactory().createProxy(resultObject, lazyLoader, configuration, objectFactory, constructorArgTypes, constructorArgs);
                break;
            }
        }
    }
    this.useConstructorMappings = resultObject != null && !constructorArgTypes.isEmpty(); // set current mapping result
    return resultObject;
}

DefaultResultSetHandler#applyPropertyMappings

获取ResultSet中的列名
获取resultMap标签中的映射配置
调用方法getPropertyMappingValue获取对应的结果值
拿到映射关系对应的属性名称
调用metaObject.setValue方法对属性进行赋值

java复制代码private boolean applyPropertyMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, ResultLoaderMap lazyLoader, String columnPrefix)
        throws SQLException {
    // 获取ResultSet中的列名
    final List<String> mappedColumnNames = rsw.getMappedColumnNames(resultMap, columnPrefix);
    boolean foundValues = false;
    // 获取resultMap映射配置
    final List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();
    for (ResultMapping propertyMapping : propertyMappings) {
        // 获取映射配置中的完整列名
        String column = prependPrefix(propertyMapping.getColumn(), columnPrefix);
        if (propertyMapping.getNestedResultMapId() != null) {
            // the user added a column attribute to a nested result map, ignore it
            column = null;
        }
        if (propertyMapping.isCompositeResult()
                || (column != null && mappedColumnNames.contains(column.toUpperCase(Locale.ENGLISH)))
                || propertyMapping.getResultSet() != null) {
            // 根据列名获取对应的值
            Object value = getPropertyMappingValue(rsw.getResultSet(), metaObject, propertyMapping, lazyLoader, columnPrefix);
            // issue #541 make property optional
            // 获取映射配置中那个属性名
            final String property = propertyMapping.getProperty();
            if (property == null) {
                continue;
            } else if (value == DEFERRED) {
                // 如果是懒加载，则设置当前查询成功，并且直接进入下一次循环，不再为当前属性赋值
                foundValues = true;
                continue;
            }
            if (value != null) {
                foundValues = true;
            }
            if (value != null || (configuration.isCallSettersOnNulls() && !metaObject.getSetterType(property).isPrimitive())) {
                // gcode issue #377, call setter on nulls (value is not 'found')
                // 为属性设置值
                metaObject.setValue(property, value);
            }
        }
    }
    return foundValues;
}

DefaultResultSetHandler#getPropertyMappingValue

如果当前映射是嵌套查询，则调用getNestedQueryMappingValue方法获取对应列的值
如果是普通查询，则直接调用TypeHandler中的getResult方法获取对应列的值

java复制代码private Object getPropertyMappingValue(ResultSet rs, MetaObject metaResultObject, ResultMapping propertyMapping, ResultLoaderMap lazyLoader, String columnPrefix)
        throws SQLException {
    if (propertyMapping.getNestedQueryId() != null) {
        // 执行嵌套查询
        return getNestedQueryMappingValue(rs, metaResultObject, propertyMapping, lazyLoader, columnPrefix);
    } else if (propertyMapping.getResultSet() != null) {
        // 处理resultSet属性（该属性与多结果集查询属性resultSets搭配）
        addPendingChildRelation(rs, metaResultObject, propertyMapping);   // TODO is that OK?
        return DEFERRED;
    } else {
        // 普通查询
        final TypeHandler<?> typeHandler = propertyMapping.getTypeHandler();
        final String column = prependPrefix(propertyMapping.getColumn(), columnPrefix);
        return typeHandler.getResult(rs, column);
    }
}

DefaultResultSetHandler#getNestedQueryMappingValue

如果是非懒加载，则会根据加载好的参数，立即执行查询BaseExecutor#query，并将结果返回
如果是懒加载，则会以当前属性名的全大写作为key，将执行查询所需的各项条件封装值作为value，存入lazyLoader中

java复制代码private Object getNestedQueryMappingValue(ResultSet rs, MetaObject metaResultObject, ResultMapping propertyMapping, ResultLoaderMap lazyLoader, String columnPrefix)
        throws SQLException {
    // 获取嵌套查询的需要的参数
    final String nestedQueryId = propertyMapping.getNestedQueryId();
    final String property = propertyMapping.getProperty();
    final MappedStatement nestedQuery = configuration.getMappedStatement(nestedQueryId);
    final Class<?> nestedQueryParameterType = nestedQuery.getParameterMap().getType();
    final Object nestedQueryParameterObject = prepareParameterForNestedQuery(rs, propertyMapping, nestedQueryParameterType, columnPrefix);
    Object value = null;
    // 查询参数不为空
    if (nestedQueryParameterObject != null) {
        // 获取SQL
        final BoundSql nestedBoundSql = nestedQuery.getBoundSql(nestedQueryParameterObject);
        // 生成CacheKey
        final CacheKey key = executor.createCacheKey(nestedQuery, nestedQueryParameterObject, RowBounds.DEFAULT, nestedBoundSql);
        final Class<?> targetType = propertyMapping.getJavaType();
        if (executor.isCached(nestedQuery, key)) {
            executor.deferLoad(nestedQuery, metaResultObject, property, key, targetType);
            value = DEFERRED;
        } else {
            final ResultLoader resultLoader = new ResultLoader(configuration, executor, nestedQuery, nestedQueryParameterObject, targetType, key, nestedBoundSql);
            // 是否懒加载
            if (propertyMapping.isLazy()) {
                // 懒加载，将懒加载的属性放入lazyLoader中
                lazyLoader.addLoader(property, metaResultObject, resultLoader);
                value = DEFERRED;
            } else {
                // 非懒加载直接执行查询
                value = resultLoader.loadResult();
            }
        }
    }
    return value;
}

到这里，如果是懒加载，则懒加载的属性值为空，查询结束；如果不是懒加载，嵌套内部查询在查询出结果后，对该属性赋值，整个嵌套查询就结束了。而如果是懒加载，返回的对象是一个代理对象，当调用对象中的方法时就会走到代理类的intercept方法中。

由于在XML中配置了CGLIB代理，因此这里走到了CglibProxyFactory类中。这里可以配置使用CGLIB代理或者JDK代理。

1 2	xml复制代码<!--指定 Mybatis 创建具有延迟加载能力的对象所用到的代理工具。CGLIB \| JAVASSIST--> <setting name="proxyFactory" value="CGLIB"/>

CglibProxyFactory.EnhancedResultObjectProxyImpl#intercept

普通方法调用，进入到else代码块
对于激进加载属性aggressive，可以在XML中进行配置

1
2

xml复制代码<!--当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加载,默认值false-->
<setting name="aggressiveLazyLoading" value="false"/>

当调用属性的get方法，并且lazyLoader中包含有该属性，则加载该属性的值

java复制代码/**
 * 代理类的拦截方法
 * @param enhanced 代理对象本身
 * @param method 被调用的方法
 * @param args 每调用的方法的参数
 * @param methodProxy 用来调用父类的代理
 * @return 方法返回值
 * @throws Throwable
 */
@Override
public Object intercept(Object enhanced, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
    // 取出被代理类中此次被调用的方法的名称
    final String methodName = method.getName();
    try {
        synchronized (lazyLoader) { // 防止属性的并发加载
            if (WRITE_REPLACE_METHOD.equals(methodName)) { // 被调用的是writeReplace方法
                // 创建一个原始对象
                Object original;
                if (constructorArgTypes.isEmpty()) {
                    original = objectFactory.create(type);
                } else {
                    original = objectFactory.create(type, constructorArgTypes, constructorArgs);
                }
                // 将被代理对象的属性拷贝进入新创建的对象
                PropertyCopier.copyBeanProperties(type, enhanced, original);
                if (lazyLoader.size() > 0) { // 存在懒加载属性
                    // 则此时返回的信息要更多，不仅仅是原对象，还有相关的懒加载的设置等信息。因此使用CglibSerialStateHolder进行一次封装
                    return new CglibSerialStateHolder(original, lazyLoader.getProperties(), objectFactory, constructorArgTypes, constructorArgs);
                } else {
                    // 没有未懒加载的属性了，那直接返回原对象进行序列化
                    return original;
                }
            } else {
                if (lazyLoader.size() > 0 && !FINALIZE_METHOD.equals(methodName)) { // 存在懒加载属性且被调用的不是finalize方法
                    if (aggressive || lazyLoadTriggerMethods.contains(methodName)) { // 设置了激进懒加载或者被调用的方法是能够触发全局懒加载的方法
                        // 完成所有属性的懒加载
                        lazyLoader.loadAll();
                    } else if (PropertyNamer.isSetter(methodName)) {  // 调用了属性写方法
                        // 则先清除该属性的懒加载设置。该属性不需要被懒加载了
                        final String property = PropertyNamer.methodToProperty(methodName);
                        lazyLoader.remove(property);
                    } else if (PropertyNamer.isGetter(methodName)) { // 调用了属性读方法
                        final String property = PropertyNamer.methodToProperty(methodName);
                        // 如果该属性是尚未加载的懒加载属性，则进行懒加载
                        if (lazyLoader.hasLoader(property)) {
                            lazyLoader.load(property);
                        }
                    }
                }
            }
        }
        // 触发被代理类的相应方法。能够进行到这里的是除去writeReplace方法外的方法，例如读写方法、toString方法等
        return methodProxy.invokeSuper(enhanced, args);
    } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
    }
}

以上就是Mybatis懒加载的实现原理。

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

Conn的goroutine

ServeMux的自定义

使用默认的多路复用器（DefaultServeMux）

使用自己创建的多路复用器

结构体 ServeMux

func (*ServeMux)

func (*ServeMux)

func (*ServeMux)

func (*ServeMux)

使用实现ServerHTTP的类型来自定义的处理器处理请求

通过 Server 结构对服务器进行更详细的配置

Profiles

PropertySource

使用@PropertySource

**1** **、哪些情况下的对象会被垃圾回收机制处理掉？**

1.1****哪些对象可以被看做是** GC ****Roots ****呢？**

1.2**对象不可达，一定会被垃圾收集器回收么？**

**2** **、讲一下常见编码方式？**

**3 **、 **utf-8 **编码中的中文占几个字节； **int** **型几个字节？**

**4** **、静态代理和动态代理的区别，什么场景使用？**

**5 **、 **Java** **的异常体系**

**6** **、谈谈你对解析与分派的认识。**

**7** **、修改对象** **A** **的** **equals** **方法的签名，那么使用** ****HashMap 存放这个对象实例的时候，会调用哪个**** equals 方法？

**8 **、 **Java** **中实现多态的机制是什么？**

**9** **、如何将一个** **Java** **对象序列化到文件里？**

**10** **、说说你对** **Java** **反射的理解**

**11** **、说说你对** **Java** **注解的理解**

**注解的作用：**

**12** **、说一下泛型原理，并举例说明**

**13 **、 **Java** **中** **String** **的了解**

**14 **、 **String** **为什么要设计成不可变的？**

简介

GET方法上传数据

POST方法上传数据

POST方法上传文件

总结

一、MySQL中如何表示当前时间？

二、关于TIMESTAMP和DATETIME的比较

三、关于TIMESTAMP和DATETIME的自动初始化和更新

socket

socket通信的条件：IP和端口

形象比喻

客户端实现过程

服务器实现过程

演示

实现持续通信过程

问题演示

简易版轮询锁

问题1：死循环

反例

优化版

问题2：线程饿死

反例

优化版

总结

参考 & 鸣谢

并发原创文章推荐

🌲 前言

☀️ 介绍

🍉 编译 CBL 镜像文件

编译环境准备

vagrant 安装 ubuntu 18.04

连接主机修改密码

先决条件配置

下载 CBL-Mariner 项目

构建 VHD 或 VHDX 镜像

构建 VHDX 镜像

构建 VHD 镜像

构建 cloud-init 配置镜像

新建并访问主机

构建 ISO 镜像

用 ISO 镜像安装系统

终端模式安装

图形化模式安装

❄️ 写在最后

时序图

BaseExecutor#query

DefaultResultSetHandler#getRowValue

DefaultResultSetHandler#createResultObject

DefaultResultSetHandler#applyPropertyMappings

1 、哪些情况下的对象会被垃圾回收机制处理掉？

1.1哪些对象可以被看做是 GC Roots 呢？

1.2对象不可达，一定会被垃圾收集器回收么？

2 、讲一下常见编码方式？

3 、 utf-8 编码中的中文占几个字节； int 型几个字节？

4 、静态代理和动态代理的区别，什么场景使用？

5 、 Java 的异常体系

6 、谈谈你对解析与分派的认识。

7 、修改对象 A 的 equals 方法的签名，那么使用 HashMap 存放这个对象实例的时候，会调用哪个 equals 方法？

8 、 Java 中实现多态的机制是什么？

9 、如何将一个 Java 对象序列化到文件里？

10 、说说你对 Java 反射的理解

11 、说说你对 Java 注解的理解

注解的作用：

12 、说一下泛型原理，并举例说明

13 、 Java 中 String 的了解

14 、 String 为什么要设计成不可变的？