学习 Spring (六) 自动装配

Spring入门篇 学习笔记

  1. No: (默认)不做任何操作
  2. byName: 根据属性名自动装配。此选项将检查容器并根据名字查找与属性完全一致的 bean，并将其与属性自动装配
  3. byType: 如果容器中存在一个与指定属性类型相同的 bean，那么将与该属性自动装配；如果存在多个该类型的 bean，那么抛出异常，并指出不能使用 byType 方式进行自动装配；如果没有找到相匹配的 bean，则什么事都不发生
  4. constructor: 与 byType 方式类似，不同之处在于它应用于构造器参数。如果容器中没有找到与构造器参数类型一致的 bean 则抛出异常

准备工作，添加 AutoWiringDAO：

1
2
3
4
5
6
7
public class AutoWiringDAO {
	
	public void say(String word) {
		System.out.println("AutoWiringDAO : " + word);
	}

}

byName

添加 AutoWiringServiceByName：

1
2
3
4
5
6
7
8
9
10
11
12
13
public class AutoWiringServiceByName {
	
	private AutoWiringDAO autoWiringDAO;

	public void setAutoWiringDAO(AutoWiringDAO autoWiringDAO) {
		this.autoWiringDAO = autoWiringDAO;
	}
	
	public void say(String word) {
		this.autoWiringDAO.say(word);
	}

}

添加配置文件 spring-autowiring-byname.xml：

1
2
3
4
5
6
7
8
9
10
11
12
<?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.xsd" 
        default-autowire="byName">
        
        <bean id="autoWiringService" class="com.karonda.autowiring.AutoWiringServiceByName" ></bean>
        
        <bean id="autoWiringDAO" class="com.karonda.autowiring.AutoWiringDAO" ></bean>
	
 </beans>

添加测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@RunWith(BlockJUnit4ClassRunner.class)
public class TestAutoWiringByName extends UnitTestBase {
	
	public TestAutoWiringByName() {
		super("classpath:spring-autowiring-byname.xml");
	}
	
	@Test
	public void testSay() {
		AutoWiringServiceByName service = super.getBean("autoWiringService");
		service.say(" this is a test");
	}

}

byType

添加 AutoWiringServiceByType：

1
2
3
4
5
6
7
8
9
10
11
12
13
public class AutoWiringServiceByType {
	
	private AutoWiringDAO autoWiringDAO;

	public void setAutoWiringDAO(AutoWiringDAO autoWiringDAO) {
		this.autoWiringDAO = autoWiringDAO;
	}
	
	public void say(String word) {
		this.autoWiringDAO.say(word);
	}

}

添加配置文件 spring-autowiring-bytype.xml：

1
2
3
4
5
6
7
8
9
10
11
12
<?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.xsd" 
        default-autowire="byType">
        
        <bean id="autoWiringService" class="com.karonda.autowiring.AutoWiringServiceByType" ></bean>
        
        <bean class="com.karonda.autowiring.AutoWiringDAO" ></bean>
	
 </beans>

添加测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@RunWith(BlockJUnit4ClassRunner.class)
public class TestAutoWiringByType extends UnitTestBase {

	public TestAutoWiringByType() {
		super("classpath:spring-autowiring-bytype.xml");
	}
	
	@Test
	public void testSay() {
		AutoWiringServiceByType service = super.getBean("autoWiringService");
		service.say(" this is a test");
	}

}

constructor

添加 AutoWiringServiceConstructor

1
2
3
4
5
6
7
8
9
10
11
12
public class AutoWiringServiceConstructor {
	
	private AutoWiringDAO autoWiringDAO;

	public AutoWiringServiceConstructor(AutoWiringDAO autoWiringDAO){
		this.autoWiringDAO = autoWiringDAO;
	}
	public void say(String word) {
		this.autoWiringDAO.say(word);
	}

}

添加配置文件 spring-autowiring-constructor.xml：

1
2
3
4
5
6
7
8
9
10
11
12
<?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.xsd" 
        default-autowire="constructor">
        
        <bean id="autoWiringService" class="com.karonda.autowiring.AutoWiringServiceConstructor" ></bean>
        
        <bean class="com.karonda.autowiring.AutoWiringDAO" ></bean>
	
 </beans>

添加测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@RunWith(BlockJUnit4ClassRunner.class)
public class TestAutoWiringConstructor extends UnitTestBase {

	public TestAutoWiringConstructor() {
		super("classpath:spring-autowiring-constructor.xml");
	}
	
	@Test
	public void testSay() {
		AutoWiringServiceConstructor service = super.getBean("autoWiringService");
		service.say(" this is a test");
	}

}

源码：learning-spring

展开全文 >>

学习 Spring (五) Aware 接口

Spring入门篇 学习笔记

Spring 中提供了一些以 Aware 结尾的接口，实现了 Aware 接口的 bean 在被初始化之后可以获取相应资源

  • 通过 Aware 接口，可以对 Spring 相应资源进行操作(一定要慎重)
  • 为对 Spring 进行简单的扩展提供了方便的入口

示例

ApplicationContextAware

添加配置文件 spring-aware-applicationcontext.xml：

1
2
3
4
5
6
7
8
9
<?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.xsd" >
        
         <bean id="moocApplicationContext" class="com.karonda.aware.MoocApplicationContext" ></bean>
        
 </beans>

实现接口：

1
2
3
4
5
6
7
8
9
public class MoocApplicationContext implements ApplicationContextAware  {
	
	@Override
	public void setApplicationContext(ApplicationContext applicationContext)
			throws BeansException {
		System.out.println("MoocApplicationContext : " + applicationContext.getBean("moocApplicationContext").hashCode());
	}
	
}

添加测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
@RunWith(BlockJUnit4ClassRunner.class)
public class TestApplicationContextAware extends UnitTestBase {
	
	public TestApplicationContextAware() {
		super("classpath:spring-aware-applicationcontext.xml");
	}
	
	@Test
	public void testMoocApplicationContext() {
		System.out.println("testMoocApplicationContext : " + super.getBean("moocApplicationContext").hashCode());
	}
	
}

MoocBeanName

添加配置文件 classpath:spring-aware-beanname.xml：

1
2
3
4
5
6
7
8
9
<?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.xsd" >

	<bean id="moocBeanName" class="com.karonda.aware.MoocBeanName" ></bean>
        
 </beans>

实现接口：

1
2
3
4
5
6
7
8
public class MoocBeanName implements BeanNameAware {
	
	@Override
	public void setBeanName(String name) {
		System.out.println("MoocBeanName : " + name);
	}

}

添加测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
@RunWith(BlockJUnit4ClassRunner.class)
public class TestBeanNameAware extends UnitTestBase {

	public TestBeanNameAware() {
		super("classpath:spring-aware-beanname.xml");
	}
	
	@Test
	public void textMoocBeanName() {
		System.out.println("textMoocBeanName : " + super.getBean("moocBeanName"));
	}
	
}

同时实现 ApplicationContextAware 和 MoocBeanName

修改 MoocBeanName：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class MoocBeanName implements BeanNameAware, ApplicationContextAware {

	private String beanName;
	
	@Override
	public void setBeanName(String name) {
		this.beanName = name;
		System.out.println("MoocBeanName : " + name);
	}

	@Override
	public void setApplicationContext(ApplicationContext applicationContext)
			throws BeansException {
		System.out.println("setApplicationContext : " + applicationContext.getBean(this.beanName).hashCode());
	}

}

修改 TestBeanNameAware：

1
2
3
4
5
6
7
8
9
10
11
12
13
@RunWith(BlockJUnit4ClassRunner.class)
public class TestBeanNameAware extends UnitTestBase {

	public TestBeanNameAware() {
		super("classpath:spring-aware-beanname.xml");
	}
	
	@Test
	public void textMoocBeanName() {
		System.out.println("textMoocBeanName : " + super.getBean("moocBeanName").hashCode());
	}
	
}

源码：learning-spring

展开全文 >>

学习 Spring (四) Bean 的生命周期

Spring入门篇 学习笔记

定义 –> 初始化 –> 使用 –> 销毁

初始化

  1. 实现 org.springframework.beans.factory.InitializingBean 接口，覆盖 afterPropertiesSet 方法

    1
    2
    3
    4
    5
    6
    public class ExampleBean implements InitializingBean{
    	public void afterPropertiesSet() throws Exception{
    	// do some initialization work
    	}
    	
    }

  2. 配置 init-method:

    1
    <bean id="exampleInitBean" class="example.ExampleBean" init-method="start"/>
    1
    2
    3
    4
    5
    6
    public class ExampleBean{
    	public void start(){
    	// do some initialization work
    	}
    	
    }

销毁

  1. 实现 org.springframework.beans.factory.DisposableBean 接口，覆盖 destory 方法

    1
    2
    3
    4
    5
    6
    public class ExampleBean implements DisposableBean{
    	public void destory() throws Exception{
    	// do some destruction work
    	}
    	
    }

  2. 配置 destory-method

    1
    <bean id="exampleInitBean" class="example.ExampleBean" destory-method="stop"/>
    1
    2
    3
    4
    5
    6
    public class ExampleBean{
    	public void stop(){
    	// do some destruction work
    	}
    	
    }

配置全局默认初始化、销毁方法

1
2
3
4
5
6
7
8
<?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.xsd" 
		default-init-method="init" default-destory-method="destory">
	
 </beans>

多种方式同时使用执行顺序

  1. afterPropertiesSet()
  2. init-method / default-init-method
  3. destory()
  4. destory-method / default-destory-method
  • 如果同时配置了 init-method 和 default-init-method 或 destory-method 和 default-destory-method，default-init-method 或 default-destory-method 不执行
  • default-init-method 和 default-destory-method 可以不在 Bean 中声明

源码：learning-spring

展开全文 >>

学习 Spring (三) Bean 的配置项 & 作用域

Spring入门篇 学习笔记

配置项

  • Id: 整个 IoC 容器中的唯一标识
  • Class: 具体实例化的类(必须配置项)
  • Scope: 作用域
  • Constructor arguments: 构造器参数
  • Properties: 属性
  • Autowiring mode: 自动装配模式
  • lazy-initialization mode: 懒加载模式
  • Initialization/destruction method: 初始化/销毁 方法

作用域

  • singleton: 单例(默认模式)，指一个 Bean 容器中只存在一份
  • prototype: 每次请求(每次使用创建新的实例)，destory 方式不生效
  • request: 每次 http 请求创建一个实例且仅在当前 request 內有效
  • session: 同上，每次 http 请求创建，当前 session 内有效
  • global session: 基于 portlet 的 web 中有效(portlet 定义了 global session)，如果是在 web 中同 session

作用域示例

添加 BeanScope：

1
2
3
4
5
6
7
public class BeanScope {
	
	public void say() {
		System.out.println("BeanScope say : " + this.hashCode());
	}
	
}

singleton

添加配置文件 spring-beanscope-singleton.xml：

1
2
3
4
5
6
7
8
9
<?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.xsd" >
        
        <bean id="beanScope" class="com.karonda.bean.BeanScope" scope="singleton"></bean>
        
 </beans>

添加测试 TestBeanScopeSingleton：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@RunWith(BlockJUnit4ClassRunner.class)
public class TestBeanScopeSingleton extends UnitTestBase {
	
	public TestBeanScopeSingleton() {
		super("classpath*:spring-beanscope-singleton.xml");
	}
	
	@Test
	public void testSay() {
		BeanScope beanScope = super.getBean("beanScope");
		beanScope.say();
		
		BeanScope beanScope2 = super.getBean("beanScope");
		beanScope2.say();
	}

}

prototype

添加配置文件 spring-beanscope-prototype.xml：

1
2
3
4
5
6
7
8
9
<?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.xsd" >
        
        <bean id="beanScope" class="com.karonda.bean.BeanScope" scope="prototype"></bean>
        
 </beans>

添加测试 TestBeanScopePrototype：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@RunWith(BlockJUnit4ClassRunner.class)
public class TestBeanScopePrototype extends UnitTestBase {

	public TestBeanScopePrototype() {
		super("classpath*:spring-beanscope-prototype.xml");
	}
	
	@Test
	public void testSay() {
		BeanScope beanScope = super.getBean("beanScope");
		beanScope.say();

		beanScope = super.getBean("beanScope");
		beanScope.say();
	}

}

源码：learning-spring

展开全文 >>

学习 Spring (二) Spring 注入

Spring入门篇 学习笔记

常用的两种注入方式

  1. 设值注入
  2. 构造注入

示例准备工作

添加 InjectionDAO：

1
2
3
4
5
public interface InjectionDAO {
	
	void save(String arg);
	
}

添加 InjectionDAOImpl：

1
2
3
4
5
6
7
public class InjectionDAOImpl implements InjectionDAO {
	
	public void save(String arg) {
		System.out.println("保存数据：" + arg);
	}

}

添加 InjectionService：

1
2
3
4
5
public interface InjectionService {
	
	void save(String arg);
	
}

设值注入

添加 InjectionServicePropertyImpl：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class InjectionServicePropertyImpl implements InjectionService {

	private InjectionDAO injectionDAO;
	
	public void setInjectionDAO(InjectionDAO injectionDAO) {
		this.injectionDAO = injectionDAO;
	}

	public void save(String arg) {
		System.out.println("Service(Property)接收参数：" + arg);
		arg = arg + ":" + this.hashCode();
		injectionDAO.save(arg);
	}
	
}

添加配置文件 classpath:spring-injection-property.xml：

1
2
3
4
5
6
7
8
9
10
11
12
<?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.xsd" >
        
     <bean id="injectionService" class="com.karonda.ioc.injection.service.InjectionServicePropertyImpl">
        <property name="injectionDAO" ref="injectionDAO"></property>
     </bean>

    <bean id="injectionDAO" class="com.karonda.ioc.injection.dao.InjectionDAOImpl"></bean>
 </beans>

添加测试 TestInjectionProperty：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@RunWith(BlockJUnit4ClassRunner.class)
public class TestInjectionProperty extends UnitTestBase {

	public TestInjectionProperty() {
		super("classpath:spring-injection-property.xml");
	}
	
	@Test
	public void testSetter() {
		InjectionService service = super.getBean("injectionService");
		service.save("这是要保存的数据");
	}
	
}

构造注入

添加 InjectionServiceConstructorImpl：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class InjectionServiceConstructorImpl implements InjectionService {
	
	private InjectionDAO injectionDAO;
	
	//构造器注入
	public InjectionServiceConstructorImpl(InjectionDAO injectionDAO) {
		this.injectionDAO = injectionDAO;
	}

	public void save(String arg) {
		//模拟业务操作
		System.out.println("Service(Constructor)接收参数：" + arg);
		arg = arg + ":" + this.hashCode();
		injectionDAO.save(arg);
	}
	
}

添加配置文件 spring-injection-constructor.xml：

1
2
3
4
5
6
7
8
9
10
11
12
13
<?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.xsd" >

		<bean id="injectionService" class="com.karonda.ioc.injection.service.InjectionServiceConstructorImpl">
        	<constructor-arg name="injectionDAO" ref="injectionDAO"></constructor-arg>
        </bean>
        
        <bean id="injectionDAO" class="com.karonda.ioc.injection.dao.InjectionDAOImpl"></bean>
	
 </beans>

添加测试 TestInjectionConstructor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@RunWith(BlockJUnit4ClassRunner.class)
public class TestInjectionConstructor extends UnitTestBase {
	
	public TestInjectionConstructor() {
		super("classpath:spring-injection-constructor.xml");
	}

	
	@Test
	public void testCons() {
		InjectionService service = super.getBean("injectionService");
		service.save("这是要保存的数据");
	}
	
}

源码：learning-spring

展开全文 >>

学习 Spring (一) Spring 介绍

Spring入门篇 学习笔记

Spring 是什么

Spring 是一个轻量级的 IoC (控制反转)和 AOP (面向切面)的容器框架

框架与类库的区别

  1. 框架一般是封装了逻辑、高内聚的，类库则是松散的工具组合
  2. 框架专注于某一领域，类库则是更通用的

IoC 与 DI 的关系

  • IoC: 控制权的转移，应用程序本身不负责依赖对象的创建和维护，而是由外部容器负责创建和维护(获得依赖对象的过程被反转了)
  • DI: 由 IoC 容器在运行期间，动态地将某种依赖关系注入到对象之中

IoC 是一种设计思想，DI 是这种思想的一种实现

示例

添加接口

1
2
3
public interface OneInterface {
    String hello(String word);
}

实现接口

1
2
3
4
5
6
public class OneInterfaceImpl implements OneInterface {

    public String hello(String word){
        return "Word from interface \"OneInterface\": " + word;
    }
}

添加配置文件

1
2
3
4
5
6
7
8
9
<?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.xsd" >
        
	<bean id="oneInterface" class="com.karonda.ioc.interfaces.OneInterfaceImpl"></bean>
	
 </beans>

添加测试

1
2
3
4
5
6
7
8
9
10
11
12
13
@RunWith(BlockJUnit4ClassRunner.class)
public class TestOneInterface extends UnitTestBase {

    public TestOneInterface(){
        super("classpath*:spring-ioc.xml");
    }

    @Test
    public void testHello(){
        OneInterface oif = super.getBean("oneInterface");
        System.out.println(oif.hello("world"));
    }
}

其中 UnitTestBase 代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
public class UnitTestBase {
	
	private ClassPathXmlApplicationContext context;
	
	private String springXmlpath;
	
	public UnitTestBase() {}
	
	public UnitTestBase(String springXmlpath) {
		this.springXmlpath = springXmlpath;
	}
	
	@Before
	public void before() {
		if (StringUtils.isEmpty(springXmlpath)) {
			springXmlpath = "classpath*:spring-*.xml";
		}
		try {
			context = new ClassPathXmlApplicationContext(springXmlpath.split("[,\\s]+"));
			context.start();
		} catch (BeansException e) {
			e.printStackTrace();
		}
	}
	
	@After
	public void after() {
		context.destroy();
	}
	
	@SuppressWarnings("unchecked")
	protected <T extends Object> T getBean(String beanId) {
		try {
			return (T)context.getBean(beanId);
		} catch (BeansException e) {
			e.printStackTrace();
			return null;
		}
	}
	
	protected <T extends Object> T getBean(Class<T> clazz) {
		try {
			return context.getBean(clazz);
		} catch (BeansException e) {
			e.printStackTrace();
			return null;
		}
	}

}

源码：learning-spring

Bean 容器初始化

两基础个包

  1. org.springframework.beans：BeanFactory 提供配置结构和基本功能，加载并初始化 Bean
  2. org.springframework.context：ApplicationContext 保存了 Bean 对象并在 Spring 中被广泛使用

初始化 ApplicationContext 方式：

  1. 本地文件
  2. Classpath
  3. Web 应用中依赖 servlet 或 Listener

备忘：在 IDEA 中构建 Maven Spring 项目

File –> New –> Project

在 pom.xml 中添加依赖包：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>4.3.18.RELEASE</version>
</dependency>

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>4.3.18.RELEASE</version>
  <scope>test</scope>
</dependency>

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
  <scope>test</scope>
</dependency>

展开全文 >>

JavaScript 使用 toJSON 方法格式化日期

toJSON 方法可以将 Date 对象转换为 ISO-8601 标准的字符串：YYYY-MM-DDTHH:mm:ss. sssZ

1
2
3
4
var date = new Date();
// toJSON() 返回的是 UTC 时间，所以需要提前修正
date.setMinutes(date.getMinutes() - date.getTimezoneOffset()); 
date.toJSON().substr(0, 19).replace(/[-T:]/g, ''); //YYYYMMDDHHmmss
  • getMinutes: 获取 Date 对象的分钟(0~59)
  • getTimezoneOffset: 获取本地时间与 UTC 时间的分钟差
  • setMinutes: date.getMinutes() - 90 表示设置 date 为 90 分钟之前的时间

参考：

  1. JS最简便日期格式化YYYYMMDD的方法

展开全文 >>

在 Linux 使用 ngrok 实现内网穿透

本文在 64 位 CentOS 6.7 测试通过

注册账号

访问 ngrok 注册账号

下载 ngrok

1
wget -P /home/tmp/download https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip

“/home/tmp/download” 为文件保存目录，如果没有安装 wget 需要先安装 wget

解压 ngrok

1
unzip ngrok-stable-linux-amd64.zip

配置 authtoken

查看 token：

执行命令

1
./ngrok authtoken YourToken

启动

1
./ngrok http 端口

上面的启动方法退出终端后，ngrok 也会停止运行，所以不太适合。比较好的方式是执行下面命令启动：

1
nohup ./ngrok http 端口 > /dev/null &
  • nohup: nohup 是 no hang up 的缩写，该命令可以在退出登录或关闭终端后继续运行进程
  • > /dev/null: /dev/null 表示空设备，> /dev/null 即不记录日志
  • &: 指在后台运行

查看外网访问地址：

1
curl http://127.0.0.1:4040/api/tunnels

参考：

  1. ngrok get started
  2. ngrok running in background

展开全文 >>

HJ212 CRC 16 (C#)

算法

  1. CRC16 校验寄存器赋值为 0xFFFF；
  2. 取被校验串的第一个字节赋值给临时寄存器；
  3. 临时寄存器与 CRC16 校验寄存器的高位字节进行“异或”运算，赋值给 CRC16 校验寄存器；
  4. 取 CRC16 校验寄存器最后一位赋值给检测寄存器；
  5. 把 CRC16 校验寄存器右移一位；
  6. 若检测寄存器值为 1，CRC16 校验寄存器与多项式 0xA001 进行“异或”运算，赋值给 CRC16 校验寄存器；
  7. 重复步骤 4~6，直至移出 8 位；
  8. 取被校验串的下一个字节赋值给临时寄存器；
  9. 重复步骤 3~8，直至被校验串的所有字节均被校验；
  10. 返回 CRC16 校验寄存器的值。

校验码按照先高字节后低字节的顺序存放。

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public static string GetHj212Crc16(byte[] bytes)
{
	int crcRegister = 0xFFFF;
	for (int i = 0; i < bytes.Length; i++)
	{
		crcRegister = (crcRegister >> 8) ^ bytes[i];
		for (int j = 0; j < 8; j++)
		{
			int check = crcRegister & 0x0001;
			crcRegister >>= 1;
			if (check == 0x0001)
			{
				crcRegister ^= 0xA001;
			}
		}
	}

	string result = string.Format("{0:X}", crcRegister);//转十六进制
	for (int i = result.Length; i < 4; i++)//补足 4 位
	{
		result = "0" + result;
	}

	return result;
}

代码地址：Hj212Crc16

展开全文 >>

Modbus CRC 16 (C#)

算法

1．预置一个值为 0xFFFF 的 16 位寄存器，此寄存器为 CRC 寄存器。
2．把第 1 个 8 位二进制数据（即通信消息帧的第 1 个字节）与 16 位的 CRC 寄存器相异或，异或的结果仍存放在该 CRC 寄存器中。
3．把 CRC 寄存器的内容右移一位，用 0 填补最高位，并检测移出位是 0 还是 1.
4．如果移出位为0 ，则重复步骤（3）（再次右移一位）；如果移出位为 1，则 CRC 寄存器与 0xA001 （多项式码）进行异或。
5．重复步骤（3）和（4），直到右移 8 次，这样整个 8 位数据全部进行了处理。
6．重复步骤（2）~（5），进行消息帧下一个字节的处理。
7．将该通信消息帧所有字节按上述步骤计算完成后，得到的 16 位 CRC 寄存器的高、低位进行交换。即发送时首先添加低位字节，然后添加高位字节。
8．最后得到的 CRC 寄存器内容即为CRC 校验码。

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public static byte[] GetModbusCrc16(byte[] bytes)
{
	byte crcRegister_H = 0xFF, crcRegister_L = 0xFF;// 预置一个值为 0xFFFF 的 16 位寄存器

	byte polynomialCode_H = 0xA0, polynomialCode_L = 0x01;// 多项式码 0xA001

	for (int i = 0; i < bytes.Length; i++)
	{
		crcRegister_L = (byte)(crcRegister_L ^ bytes[i]);

		for (int j = 0; j < 8; j++)
		{
			byte tempCRC_H = crcRegister_H;
			byte tempCRC_L = crcRegister_L;

			crcRegister_H = (byte)(crcRegister_H >> 1);
			crcRegister_L = (byte)(crcRegister_L >> 1);
			// 高位右移前最后 1 位应该是低位右移后的第 1 位：如果高位最后一位为 1 则低位右移后前面补 1
			if ((tempCRC_H & 0x01) == 0x01)
			{
				crcRegister_L = (byte)(crcRegister_L | 0x80);
			}

			if ((tempCRC_L & 0x01) == 0x01)
			{
				crcRegister_H = (byte)(crcRegister_H ^ polynomialCode_H);
				crcRegister_L = (byte)(crcRegister_L ^ polynomialCode_L);
			}
		}
	}

	return new byte[] { crcRegister_L, crcRegister_H };
}

代码地址：ModbusCrc16

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家