Spring （ 二 ） IOC 依赖注入
个人博客网：https://wushaopei.github.io/ (你想要这里多有)
1、什么是IOC
IOC 全称指的是 Inverse Of Control 控制反转。
原来我们使用Spring之前对象都是通过代码 new 对象()来自己进行创建。
现在使用了Spring之后。只需要在Spring的配置文件中进行配置，那么spring就会帮我们new出对象来。
2、什么是DI
DI 指的是Dependency Injection 。是依赖注入的意思。
BookService{
BookDao bookDao;
public void setBookDao( BookDao bookDao ){
this.bookDao = bookDao;
}
}
只需要配置就可以把依赖的对象的值注入到引用中。
3、第一个IOC示例程序 -- 通过id获取对象（重点）
实验1：通过IOC容器创建对象，并为属性赋值★
1、创建一个Java工程：
创建相应的类
person类代码
为节省空间，省略get\set方法，toString不写
package com.webcode.pojo;
import java.util.List;
import java.util.Map;
import java.util.Properties;
/** * @author Administrator *
*/
public class Person {
private Integer id;
private String name;
private Integer age;
private String phone;
private Car car;
public Person() {
super();
// TODO Auto-generated constructor stub
}
public Person(Integer id, String name, Integer age, String phone, Car car) {
super();
this.id = id;
this.name = name;
this.age = age;
this.phone = phone;
this.car = car;
}
Car 类的代码
public class Car {
/*
省略 get\set方法 和 toString方法不写
*/
private String name;
private String carNo;
public Car() {
super();
// TODO Auto-generated constructor stub
}
public Car(String name, String carNo) {
super();
this.name = name;
this.carNo = carNo;
}
}
2、导入jar包：
- commons-logging-1.1.3.jar
- log4j-1.2.17.jar
- spring-beans-4.3.18.RELEASE.jar
- spring-context-4.3.18.RELEASE.jar
- spring-core-4.3.18.RELEASE.jar
- spring-expression-4.3.18.RELEASE.jar
applicationContext.xml配置文件内容如下：
<!--
bean标签标识要配置一个bean对象
class 属性配置你要陪哪个Bean对象的全类名
id 属性给配置的Bean对象起一个唯一标识
-->
<bean id="p1" class="com.webcode.pojo.Person">
<!--
property 标签配置属性的值
name 标识你要配置哪个属性
value 属性配置这个属性的值
-->
<property name="id" value="1"></property>
<property name="name" value="旻"></property>
<property name="age" value="25"></property>
<property name="phone" value="148999999"></property>
</bean>
测试的代码：
@Test
public void test1()throws Exception {
//ApplicationContext 表示SpringIOC 容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//使用了Spring之后。对象都交给Spring窗口来创建和管理
//Spring 容器就是一个map，然后id是key class 时哪个value
Person person = (Person) applicationContext.getBean("p1");
System.out.println(person);
}
打印结果：
问题：
1、FileSystemXmlApplicationContext怎么用?
答：跟使用JavaSE的相对路径一样
2、Bean是在什么时候被创建的?
答：在创建Spring容器的时候，创建Bean对象（默认）
- 如果调用getBean多次，会创建几个?
答：默认创建同一个
常见的错误：
指定的id不存在。找不到bean对象。
4、IOC示例程序 -- 通过类型获取对象（重点）
实验2：根据bean的类型从IOC容器中获取bean的实例★
配置文件代码：
<bean id="p2" class="com.webcode.pojo.Person" >
<!-- property 标签配置属性的值
name 标识你要配置哪个属性
value 属性配置这个属性的值 -->
<property name="id" value="2"></property>
<property name="name" value="旻"></property>
<property name="age" value="25"></property>
<property name="phone" value="148999999"></property>
</bean>
@Test
public void test2()throws Exception{
ApplicationContext applicationContext =new ClassPathXmlApplicationContext("applicationContext.xml");
*
* 按类型查找，找到一个就直接返回
* 没有找到就报错
* 找到多个也报错
*
System.out.println(applicationContext.getBean(Person.class));
}
常见错误说明：
按类型查找，找不到就报错
当在applicationContext.xml配置文件中。有多个同Person.class类型实现的时候。
5、IOC示例程序 -- 通过构造方法参数名注入值
实验3：通过构造器为bean的属性赋值
<bean id="p3" class="com.webcode.pojo.Person">
<!-- constructor-arg 是按构造器参数赋值
name 给哪个属性赋值
value 传递的参数值 -->
<constructor-arg name="name" value="王玄策" />
<constructor-arg name="id" value="3" />
<constructor-arg name="age" value="38" />
<constructor-arg name="phone" value="198745632" />
</bean>
测试代码：
@Test
public void test3()throws Exception{
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println(applicationContext.getBean("p3"));
}
打印结果:
6、IOC示例程序 -- index属性指定参数的位置
实验4：通过index属性指定参数的位置
<bean id="p4" class="com.webcode.pojo.Person">
<!-- constructor-arg 是按构造器参数赋值
name 给哪个属性赋值
value 传递的参数值 -->
<constructor-arg index="1" value="大汉光武" />
<constructor-arg index="0" value="4" />
<constructor-arg index="2" value="26" />
<constructor-arg index="3" value="1888951233" />
</bean>
测试代码：
@Test
public void test4()throws Exception{
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println(applicationContext.getBean("p4"));
}
打印结果：
7、IOC示例程序 -- 根据参数类型注入
实验5：根据参数类型注入
public Person(Integer id, String name, Integer age, String phone) {
super();
System.out.println("创建了Person==有参");
this.id = id;
this.name = name;
this.age = age;
this.phone = phone;
}
public Person(Integer id, String name, String phone,Integer age) {
super();
System.out.println("创建了Person==有参");
this.id = id;
this.name = name;
this.age = age;
this.phone = phone;
}
配置信息：
<bean id="p5" class="com.webcode.pojo.Person">
<!-- Integer id, String name, Integer age, String phone
constructor-arg 是按构造器参数赋值
index 构造参数的索引
value 传递的参数值 -->
<constructor-arg index="0" value="4" type="java.lang.Integer"></constructor-arg>
<constructor-arg index="1" value="帅才" type="java.lang.String"></constructor-arg>
<constructor-arg index="2" value="19" type="java.lang.Integer"></constructor-arg>
<constructor-arg index="3" value="18" type="java.lang.String"></constructor-arg>
</bean>
测试代码：
@Test
public void test5()throws Exception{
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println(applicationContext.getBean("p5"));
}
打印结果：
8、IOC之 P名称空间
实验6：通过p名称空间为bean赋值
配置信息：
<!-- p名称空间是同过set方法复制 -->
<bean id="p6" class="com.webcode.pojo.Person"
p:id="6" p:age="25" p:name="旻" p:phone="145665389">
</bean>
测试代码：
@Test
public void test6()throws Exception{
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println(applicationContext.getBean("p6"));
}
打印结果：
9、测试null值的使用
实验7：测试使用null值
配置信息：
<!-- 测试null值的应用 -->
<bean id="p7 " class="com.webcode.pojo.Person">
<property name="id" value="7"></property>
<property name="name"><null></null></property>
</bean>
测试代码：
@Test
public void test7() throws Exception {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
Person person = (Person) applicationContext.getBean("p7");
System.out.println( person.getName().length() );
}
10、IOC之子对象的赋值测试（重点）
实验8：引用其他bean★
创建个新的工程。测试Spring的开发环境。此不重复。请参阅前面，环境搭建。
Car对象
public class Car {
private String name;
private String carNo;
public class Person {
private Integer id;
private String name;
private Integer age;
private String phone;
private Car car;
配置信息：
<bean id="car" class="com.webcode.pojo.Car" p:name="宝马" p:carNo="京B123412"/>
<bean id="p8" class="com.webcode.pojo.Person">
<property name="id" value="8" />
<!--
car属性，可以通过ref（引用的意思）某个指定id值的对象
-->
<property name="car" ref="car" />
</bean>
测试代码：
@Test
public void test8() throws Exception {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
Person person = (Person) applicationContext.getBean("p8");
System.out.println( person );
}
打印结果：
11、IOC之内部Bean的使用
实验9：引用内部bean
配置信息：
<!-- 引用内部bean -->
<bean id="p9" class="com.webcode.pojo.Person">
<property name="id" value="9"></property>
<property name="car">
<!-- 内部bean ,不能被外部使用 -->
<bean id="car02" class="com.webcode.pojo.Car" p:name="内部car" p:carNo="京B123422" />
</property>
</bean>
测试代码：
@Test
public void test9() throws Exception {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
Person person = (Person) applicationContext.getBean("p9");
System.out.println( person );
System.out.println( applicationContext.getBean("car02") );
}
打印结果：
常见错误：内部的Bean不能被外部使用
12、IOC之List属性的赋值
实验10：使用list子元素为List类型的属性赋值
Person对象
配置的信息：
<bean id="p10" class="com.webcode.pojo.Person">
<property name="id" value="9"></property>
<property name="list">
<!-- list标签，表示当前配置一个list集合 -->
<list>
<value>文</value>
<value>星</value>
<value>念</value>
</list>
</property>
</bean>
------------------------------------------ 此处省略测试代码！
打印结果
13、IOC之Map属性的赋值
实验11：使用map子元素为Map类型的属性赋值
配置信息：
<!-- 实验11：使用map子元素为Map类型的属性赋值 -->
<bean id="p11" class="com.webcode.pojo.Person">
<property name="id" value="9"></property>
<property name="map">
<!-- map标签，表示当前配置一个map集合 -->
<map>
<entry key="key1" value="远方"></entry>
<entry key="key2" value="流星"></entry>
<entry key="key3" value-ref="car"></entry>
</map>
</property>
</bean>
------------------------------------------ 此处省略测试代码！
打印结果：
14、IOC之Properties属性的赋值
实验12：使用prop子元素为Properties类型的属性赋值
配置信息：
<!-- 实验12：使用prop子元素为Properties类型的属性赋值 -->
<bean id="p12" class="com.webcode.pojo.Person">
<property name="id" value="9"></property>
<property name="map">
<!-- props标签，表示当前配置一个Properties -->
<props>
<prop key="user">root</prop>
<prop key="password">123456</prop>
</props>
</property>
</bean>
------------------------------------------ 此处省略测试代码！
打印结果：
15、IOC之util 名称空间
util名称空间，可以定义
实验13：通过util名称空间创建集合类型的bean
配置信息：
<!-- util名称空间引用，可以定义
实验13：通过util名称空间创建集合类型的bean-->
<!-- 定义一个list集合 -->
<util:list id="list1">
<value>string1</value>
<value>string2</value>
<value>string3</value>
</util:list>
<bean id="p13" class="com.webcode.pojo.Person">
<property name="id" value="13"></property>
<property name="name" value="旻"></property>
<property name="age" value="24"></property>
<property name="phone" value="1722235896"></property>
<!-- list对象 ref表示引用 -->
<property name="phones" ref="list1"></property>
</bean>
测试代码：
@Test
public void test13()throws Exception{
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
Person person = (Person) applicationContext.getBean("p13");
System.out.println( person );
List<String> list = (List<String>) applicationContext.getBean("list1");
System.out.println(list);
}
打印结果：
图解：
16、IOC之级联属性赋值
实验14：给bean的级联属性赋值
配置：
<!-- 实验14：给bean的级联属性赋值
常见错误：
级联属性一定要先注入对象。再注入对象的属性
-->
<bean id="p14" class="com.webcode.pojo.Person">
<property name="id" value="14"></property>
<property name="name" value="星"></property>
<property name="age" value="27"></property>
<property name="phone" value="17889652345"></property>
<!-- list对象 ref 表示引用 -->
<property name="car" ref="car"></property>
<!-- -级联属性 -->
<property name="car.name" value="凯迪拉克"></property>
</bean>
------------------------------------------ 此处省略测试代码！
打印结果：
常见错误：
级联属性一定要先注入对象。再注入对象的属性
图解：
17、IOC之静态工厂方法创建Bean
实验15：配置通过静态工厂方法创建的bean
代码：
public class PersonFactory {
public static Person createPerson() {
return new Person(1, "我是静态工厂方法创建出来的", 18, "18688886666");
}
}
配置信息：
<!-- 静态工厂方法调用创建对象
factory-method 是指调用哪个方法返回对象 -->
<bean id="p15" class="com.webcode.pojo.factory.PersonFactory"
factory-method="createPerson"/>
------------------------------------------ 此处省略测试代码！
图解：
不重写toString方法的情况下，地址值相同，调用的是同一个对象，从工厂中的方法获取
创建对象流程：
18、IOC之工厂实例方法创建Bean
实验16：配置通过实例工厂方法创建的bean
public class PersonFactory {
public Person createPerson2() {
return new Person(1, "我是工厂实例方法创建出来的", 18, "18688886666");
}
}
配置信息：
<!-- 配置工厂实例 -->
<bean id="personFactory" class="com.webcode.pojo.factory.PersonFactory"/>
<!--
factory-bean="personFactory" 表示准备调用哪个实例的方法
factory-method="createFacroty2" 是指调用哪个方法
-->
<bean id="p16" factory-bean="personFactory" factory-method="createPerson2"> </bean>
------------------------------------------ 此处省略测试代码！
打印结果：
流程图解：
19、IOC之FactoryBean接口方式创建对象
实验17：配置FactoryBean接口创建Bean对象
FactoryBean接口方式
package com.webcode.pojo.factory;
import org.springframework.beans.factory.FactoryBean;
import com.webcode.pojo.Person;
public class PersonFactoryBean implements FactoryBean<Person> {
/*
* 创建对象实例的适合，调用的方法
* */
@Override
public Person getObject() throws Exception {
return new Person(1,"我是PersonFactoryBean类",18,"14568526666");
}
/*
* 返回对象的类型，相当于class属性
* */
@Override
public Class<?> getObjectType() {
return Person.class;
}
/*
* 是否是单例
* */
@Override
public boolean isSingleton() {
return true;
}
}
配置信息：
<!--
创建一个工厂实例对象FactoryBean接口的实现类
-->
<bean id="p17" class="com.webcode.pojo.factory.PersonFactoryBean"/>
------------------------------------------ 此处省略测试代码！
打印结果：
图解流程：
20、IOC之继承Bean配置
实验18：通过继承实现bean配置信息的重用
配置信息：
<!-- 实验18：通过继承实现bean配置信息的重用 -->
<bean id="parent" class="com.webcode.pojo.Person">
<property name="id" value="100"></property>
<property name="name" value="我思念的人啊"></property>
<property name="age" value="24"></property>
<property name="phone" value="1477888999"></property>
</bean>
<!-- parent="parent" 继承指定的parentid的bean对象的配置信息-->
<bean id="p18" class="com.webcode.pojo.Person" parent="parent">
<property name="id" value="18"></property>
</bean>
------------------------------------------ 此处省略测试代码！
打印结果：
图解：先比较parent与id是否相同，再拿class进行比较，
注意：当有两个id相同，而类型不同的bean存在时，会出现ReaderContext.error读取异常
21、IOC之abstract抽象Bean定义（配置）
实验19：通过abstract属性创建一个模板bean
<!--
abstract="true"表示这是一个抽象的配置，抽象的就不能被实例化
-->
<bean id="parent" class="com.webcode.pojo.Person" abstract="true">
<property name="id" value="100"></property>
<property name="name" value="这是父亲的名称"/>
<property name="age" value="30" />
<property name="phone" value="父亲的电话" />
</bean>
22、IOC之组件创建顺序
实验20：bean之间的依赖 depends-on 属性
public class A {
public A() {
System.out.println("创建了A对象");
}
}
public class B {
public B() {
System.out.println("创建了B对象");
}
}
public class C {
public C() {
System.out.println("创建了C对象");
}
}
配置信息：
<!--
depends-on="b" 依赖b
如果你要创建a，要先有b
-->
<bean id="a" class="com.webcode.pojo.A" depends-on="b,c"/>
<bean id="b" class="com.webcode.pojo.B"/>
<bean id="c" class="com.webcode.pojo.C"/>
测试代码：
@Test
public void test1() throws Exception {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
// System.out.println( applicationContext.getBean("a") );
}
打印结果：
23、IOC之Bean的单例和多例（重点）
实验21：测试bean的作用域，分别创建单实例和多实例的bean★
<!--
scope配置作用域 分别是四个值：singleton、prototype、request、session
singleton 这是默认值 表示单例
1、当Spring容器创建的时候，单例的对象就会被创建出来。
2、单例的对象，在每次调用getBean的时候都返回同一个对象
prototype 表示多例
1、当创建Spring容器的时候，不会创建出多例的对象
2、当调用getBaen方法时，会创建一个对象
3、每次调用getBean，都会创建一个实例
===============request和Session了解======================
request 表示一次请求内，多次调用getBean都只会返回同一个对象
当调用getBean方法时内部原理类似如：
Object bean = request.getAttribute(id);
if (bean == null) {
bean = 创建一个实例;
request.setAttribute(id,bean);
}
return bean;
session 表示同一个会话，多次调用getBean都只会返回同一个对象
当调用getBean方法时内部原理类似如：
Object bean = session.getAttribute(id);
if (bean == null) {
bean = 创建一个实例;
session.setAttribute(id,bean);
}
return bean;
-->
<bean id="a" class="com.webcode.pojo.A" scope="request"></bean>
单例——singleton 打印结果：
多例——prototype打印结果：
24、基于xml配置文件的自动注入
先创建Person类和Car类
public class Car {
private String name;
private String carNo;
public class Person {
private Integer id;
private Car car;
public Person(Car car) {
this.car = car;
}
<!--
<bean id="car" class="com.webcode.pojo.Car">
<property name="name" value="海南马自达car" />
<property name="carNo" value="琼A123412"/>
</bean>
<bean id="car1" class="com.webcode.pojo.Car">
<property name="name" value="海南马自达car1" />
<property name="carNo" value="琼A123412"/>
</bean>
default和no就是不配置就没值
byName 按属性名做为id名称查找bean对象，并自动注入
1、找到就自动注入
2、找不到就null
byType 按子对象的类型查找bean对象，并自动注入
1、找到一个就自动注入
2、找到多个就报错。
3、没有找到就null
constructor 表示按构造器参数查找并自动注入
1、会先按类型查找
1.1、查找一个就自动注入
1.2、查找到多个，就继续以参数名做为id接着查找，然后注入
1.3、查找到多个，就继续以参数名做为id接着查找，没有找到就为null值
2、没有找到就是null
先按类型==>>再按参数名做为id===>>最后是null
-->
<bean id="p20" class="com.webcode.pojo.Person" autowire="constructor">
<property name="id" value="20"></property>
<!-- <property name="car" ref="car" /> -->
</bean>
测试代码：
@Test
public void test2() throws Exception {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println( applicationContext.getBean("p20") );
}
手动配置引用注入：图解
Default指令效果图解
byType 指令效果图解
匹配的子对象为class中的Car
constructor按构造器参数查找并自动注入 图解
4~6步执行set\get和toString方法
Spring （ 二 ） IOC 依赖注入的更多相关文章
- spring的IOC——依赖注入的两种实现类型
一.构造器注入: 构造器注入,即通过构造函数完成依赖关系的设定.我们看一下spring的配置文件: <constructor-arg ref="userDao4Oracle" ...
- spring的ioc依赖注入的三种方法(xml方式)
常见的依赖注入方法有三种:构造函数注入.set方法注入.使用P名称空间注入数据.另外说明下注入集合属性 先来说下最常用的那个注入方法吧. 一.set方法注入 顾名思义,就是在类中提供需要注入成员的 s ...
- Spring之 IOC&依赖注入
0x01.Spring 1什么是Spring Spring 是一个开源框架,是为了解决企业应用程序开发复杂性而创建的(解耦). 框架的主要优势之一就是其分层架构,分层架构允许您选择使用哪一个组 ...
- Spring.net Ioc 依赖注入
控制反转 (Inversion of Control,英文缩写为IoC)是一个重要的面向对象编程的法则来削减计算机程序的耦合问题,也是轻量级的Spring框架的核心. 控制反转一般分为两种类型,依赖注 ...
- spring 之 IOC 依赖注入详解
当我们对一个javaBean进行实例化时,在原本的情况下我们会选择新建一个接口,然后进行实例化,为了进一步降低耦合度我们还会使用工厂模式进行封装. 例: 当我们想要去造,Chinese.America ...
- Spring框架——IOC依赖注入
本来想把IOC和AOP一起介绍的,但是AOP内容太多了,所以就分开了,最后的结果就是这一篇只剩下一点点了.这不是第一次写关于IOC的文章了,之前写过Java反射,Java注解,也写过通过XML解析实现 ...
- Spring学习-spring核心机制-IOC依赖注入
转载自:http://www.cnblogs.com/chenssy/archive/2012/11/11/2765266.html 今天复习一下spring两大特性之一:IOC依赖注入,看了一下大佬 ...
- Spring MVC 使用介绍（十五）数据验证 （二）依赖注入与方法级别验证
一.概述 JSR-349 (Bean Validation 1.1)对数据验证进一步进行的规范,主要内容如下: 1.依赖注入验证 2.方法级别验证 二.依赖注入验证 spring提供BeanValid ...
- ASP.NET MVC IOC依赖注入之Autofac系列（二）- WebForm当中应用
上一章主要介绍了Autofac在MVC当中的具体应用,本章将继续简单的介绍下Autofac在普通的WebForm当中的使用. PS:目前本人还不知道WebForm页面的构造函数要如何注入,以下在Web ...
- Spring系列之依赖注入的方式
一.依赖注入方式 对于spring配置一个bean时,如果需要给该bean提供一些初始化参数,则需要通过依赖注入方式,所谓的依赖注入就是通过spring将bean所需要的一些参数传递到bean实例对象 ...
随机推荐
- 王颖奇 20171010129《面向对象程序设计（java）》第十周学习总结
实验十 泛型程序设计技术 实验时间 2018-11-1 1.实验目的与要求 (1) 理解泛型概念: (2) 掌握泛型类的定义与使用: (3) 掌握泛型方法的声明与使用: (4) 掌握泛型接口的定义与 ...
- 数据预处理 —— padding数据
1. 论Conv2d()里的padding和Conv2d()前padding的区别及重要性. 小生建议,尽量少用Conv2d()里的填充方式,换成自定义填充方式(强烈建议). 小生为何这样建议 ...
- Qt自定义文本输入框实现支持输入度分秒和度两种格式(简易无限制输入)
1.自定义文本输入框 #ifndef MYLINEEDIT_H #define MYLINEEDIT_H #include <QLineEdit> #include "ui_my ...
- 使用 React hooks 转化 class 的一些思考
Hooks 是 React 16.8 的新增特性.它可以让你在不编写 class 的情况下使用 state 以及其他的 React 特性. 使用 React hooks 转化 class 的一些思考 ...
- CompletableFuture的使用例子
1. CompletableFuture的介绍 在Java8时被引入,在包java.util.concurrent下,是Java多线程编程中的一个类,扩展了Future中很多功能,Completabl ...
- Python 常用编码规范
一.简明概述 1.编码 如无特殊情况, 文件一律使用 UTF-8 编码 如无特殊情况, 文件头部必须加入#-*-coding:utf-8-*-标识 2.代码格式 2.1.缩进 统一使用 4 个空格进行 ...
- 【雕爷学编程】Arduino动手做（64）---RGB全彩LED模块
37款传感器与执行器的提法,在网络上广泛流传,其实Arduino能够兼容的传感器模块肯定是不止这37种的.鉴于本人手头积累了一些传感器和执行器模块,依照实践出真知(一定要动手做)的理念,以学习和交流为 ...
- 《机器学习_07_01_svm_硬间隔支持向量机与SMO》
一.简介 支持向量机(svm)的想法与前面介绍的感知机模型类似,找一个超平面将正负样本分开,但svm的想法要更深入了一步,它要求正负样本中离超平面最近的点的距离要尽可能的大,所以svm模型建模可以分为 ...
- 10.1Go Mysql
第十章 Go Mysql 准备好mysql数据库服务端数据. 创建test数据库 MariaDB [(none)]> create database test; Query OK, 1 row ...
- ubuntu下安装perl GD模块
依次执行: sudo apt-get install libgd2-xpm-dev sudo perl -MCPAN -e shell install Bundle::CPAN install GD: ...