john's tech blog

go与Java对比之操作HttpHeader

发表于 2022-06-29

go操作HttpHeader的类在net/http/Header中

知识点：

1.go的类型转换

Header的添加方法把当前Header类型的map转换成MIMEHeader类型

type Header map[string][]string

type MIMEHeader map[string][]string


func (h Header) Add(key, value string) {
	textproto.MIMEHeader(h).Add(key, value)
}

2.大小写的转换技巧

Java 我们主要看 Spring中操作HttpHeader的类在HttpHeaders类中。

go语言笔记之Map映射入门

发表于 2022-06-29

go语言中的映射是将键映射到值。

func TestStringMap(t *testing.T) {

//// https://blog.csdn.net/weixin_35241867/article/details/112508515
var m map[string]string
//必须make
m = make(map[string]string)
m["john"] = "wonder"

t.Log(m) //输出map[john:wonder]
t.Log(m["john"]) //输出wonder

}

如果不调用make,那么在调用m["john"] = "wonder"的时候就会报如下错：

panic: assignment to entry in nil map [recovered]
panic: assignment to entry in nil map

go语言笔记之变量

发表于 2021-10-15 | 更新于 2022-06-29

变量声明类型

变量声明可以包含初始值，每个变量对应一个。

1	var i, j int = 1, 2

变量省略类型

如果初始化值已存在，则可以省略类型；变量会从初始值中获得类型。

1	var i, j = 1, 2 //也可以编译通过

函数内声明变量

在函数级别也可以声明变量

func TestVarInitialize(t *testing.T) {
	var c, python, java = true, false, "no!" //变量会从初始值中获得类型
	t.Log(i, j, c, python, java)
}

输出：1 2 true false no!

多变量一起声明

func TestMultiVarInit(t *testing.T) {
	var (
		name   string
		age    int
		gender string
	)
	name = "john"
	age = 20
	gender = "男性"
	fmt.Printf("名字为：%s,年龄： %d,性别：%s \n", name, age, gender)
}

变量在函数外部声明注意点

函数外的每个语句都必须以关键字开始（var, func 等等）， := 结构不能在函数外使用

var m = 2

在函数中，简洁赋值语句 := 可在类型明确的地方代替 var 声明。

func TestShortVarInitialize(t *testing.T) {
	var i, j int = 1, 2
  k := 3 //此处可以使用:=
	c, python, java := true, false, "no!"
	t.Log(m, i, j, k, c, python, java)
}

var 声明结构体类型

type Response struct {
	Err error
	name string
}
func TestVarStruct(t *testing.T) {
	//直接初始化
	//https://www.cnblogs.com/liyutian/p/10050320.html
	//var 声明同样也会为结构体类型的数据分配内存，所以我们才能像上一段代码中那样，在声明了 var s T 之后就能直接给他的字段进行赋值
	var resp Response
	resp.name = "john"
	t.Log(resp)

}

变量交换

go中两个相同类型变量交换可以直接在一句代码上完成，如下所示：

func TestExchange(t *testing.T) {
	a := 1
	b := 2
	a, b = b, a //go中直接赋值
	t.Log(a, b) //输出2 1
}

Go与Java声明变量的区别

java中声明变量时类型在变量名的左侧，而Go中在变量名右侧：
java中声明变量必须以分号结束,而Go中不需要分号
java中基础类型变量必须初始化才能使用，而Go中会默认初始化

未完待续…

接近Spring实现一个IOC框架之设计Bean属性值集合

发表于 2021-09-12

可变的属性值集合类

在上篇文章中的Bean定义中可以发现属性值集合接口光有属性值的获取，那属性值总得要添加并且存储起来才能获取到吧，想来想去，那就实现下这个接口，把添加和获取一次性搞定不就好了，哈哈！那就整个既可以添加修改又可以获取的属性值集合类吧，我们学下Spring大哥取名为MutablePropertyValues吧。

1 2	public class MutablePropertyValues implements PropertyValues{ }

首先我们要做的就是怎么把属性值存储起来，这里先简单点声明一个List接口类型的字段好了，体现了面向接口编程嘛。

存储属性值

1 2	//没有泛型 List propertyValueList;

初始化属性值列表

注意这里先不使用泛型，也不声明为final，好的那接下来就要定义构造函数了。先写个默认的吧：

无参默认初始化

1
2
3

public MutablePropertyValues() {
    this.propertyValueList = new ArrayList(10);
}

默认定义一个10元素容量的ArrayList给到propertyValueList。再想想我们可能会从另外一个属性值集合复制属性过来也不是不可能嘛，那么就可以定义一个具有PropertyValues接口类型参数的构造函数吧：

拷贝其他属性值集合

public MutablePropertyValues(PropertyValues other) {
    PropertyValue[] pvs = other.getPropertyValues();
    propertyValueList =new ArrayList(pvs.length);
    for (int i = 0; i < pvs.length; i++){
        addPropertyValue(new PropertyValue(pvs[i].getName(),pvs[i].getValue()));
    }
}

因为PropertyValues接口有获取属性值列表的方法，那么我们就可以直接使用它遍历添加到当前集合中，这里就体现了面向接口编程的灵活咯。其中addPropertyValue就体现了MutablePropertyValues类存在的一个作用：添加属性值。

添加属性值

1
2
3

public void addPropertyValue(PropertyValue pv){
    propertyValueList.add(pv);
}

Map初始化属性值列表

做到这里再想想，是否有可能从一个Map拷贝属性值过来呢，因为Map就是一个K-V存储嘛，完全有可能，那就再来个构造函数吧：

public MutablePropertyValues(Map map) {

    Set keys =map.keySet();
    propertyValueList = new ArrayList(keys.size());
    Iterator itr = keys.iterator();
    while (itr.hasNext()){
        String key = (String) itr.next();
        addPropertyValue(new PropertyValue(key,map.get(key)));
    }
}

内部先获取Map中key的Set集合，然后它的迭代器来遍历，爽歪歪啊！

好了，到这里我们还漏了实现PropertyValues接口定义的方法哦，不然会编译不通过的，首先就是获取属性值列表：

获取属性值列表

@Override
public PropertyValue[] getPropertyValues() {
    return  (PropertyValue[]) propertyValueList.toArray(new PropertyValue[0]);
}

很简单，直接用propertyValueList转成数组输出。接下来就实现下根据属性名称判断是否包含某个属性值咯

根据名称判断是否包含对应属性值

@Override
public boolean contains(String propertyName) {
    return getPropertyValue(propertyName) != null;
}

这个包含判断是建立在获取某个属性值基础上的。

根据名称获取对应属性值

遍历propertyValueList集合列表，循环判断名称是否相同。

@Override
public PropertyValue getPropertyValue(String propertyName) {   
   for (int i =0; i <propertyValueList.size();i++){

        PropertyValue pv = (PropertyValue) propertyValueList.get(0);      
        if(pv.getName().equals(propertyName))            
            return  pv;   
   }
   return  null;
 }

最后想一下，既然内部存储的是List，那么我们就可以直接在List的某一个位置替换属性值?!注意是替换哦 上代码：

1
2
3

public void setPropertyValueAt(PropertyValue pv,int i){  
    propertyValueList.set(i,pv);
  }

好了，到这里一个可修改的属性值集合类就大功告成了，接下来我们就该再回过头优化优化我们的Bean定义咯！

接近Spring实现一个IOC框架之Bean定义

发表于 2021-09-11

为什么需要Bean定义

我们知道Spring框架的核心是它内部的Bean工厂(在设计模式上来说也称之为IOC容器), 当我们要使用某一个在工厂托管的Bean时，工厂会帮助我们去生成，注入依赖，初始化等一系列行为，最后返回一个符合我们期望的Bean,那工厂怎么知道他要生成什么，注入哪些依赖，初始化什么呢，这就需要我们先有一个Bean定义告诉工厂我们需要怎样的Bean，其他的慢慢来也不急。

抽象的Bean定义

我们试想一下，所有的Bean是不是有一些通用的属性可以抽象出来呢？简单想想，最先想到的有是否单例，属性集合，其他一些先等等不急。那首先我们得把属性定义下吧。

属性

属性一般由属性名称和属性值构成，属性值也需要通用，那就先声明为Object类型吧，简单点：

public class PropertyValue {

    //属性名称
    private String name;

    //属性值
    private Object value;

    public PropertyValue(String name, Object value) {
        this.name = name;
        this.value = value;
    }

    public String getName() {
        return name;
    }

    public Object getValue() {
        return value;
    }
}

接下来那需要有一个集合来把Bean的所有属性集合在一起了，集合起来有啥好处呢？可以根据名称方便获取的获取到对应的属性啊！我们知道Java中List，Set都是接口，那这边我们索性也做成集合接口吧，取名为PropertyValues:

public interface PropertyValues {

    PropertyValue[] getPropertyValues();

    boolean contains(String propertyName);

    PropertyValue getPropertyValue(String propertyName);
}

手续齐全了，到这里我们就可以定义一个AbstractBeanDefinition了：

public class AbstractBeanDefinition {

    //bean是否单例
    private boolean singleton;

    //bean的属性集合
    private PropertyValues pvs;

    public AbstractBeanDefinition(boolean singleton, PropertyValues pvs) {
        this.singleton = singleton;
        this.pvs = pvs;
    }
    public AbstractBeanDefinition() {
        this.singleton=true;
    }
    public final boolean isSingleton(){
        return singleton;
    }

    public void setPvs(PropertyValues pvs) {
        this.pvs = pvs;
    }

    public PropertyValues getPvs() {
        return pvs;
    }
}

简单吧，我们把一个工厂需要的最简单的Bean定义给整出来了。接下来我们还得添加点什么呢？请看下篇。

欢迎关注我的公众号：沉迷Spring