Spring学习总结(5)——IOC注入方式总结

Wesley13
• 阅读 689

一、构造注入

在类被实例化的时候,它的构造方法被调用并且只能调用一次。所以它被用于类的初始化操作。标签的子标签。通过其子标签可以为构造
方法传递参数。现在以一个简单的输出学生信息的实例演示如何为构造方法传递参数。

实例程序创建过程如下。
(1)建立 Student 接口,它是对学生类的简单抽象。程序代码如下

[java]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. package com.linbingwen;

  2. public interface Student {

  3. public void printInfo();

  4. }

(2)建立实现 Student 接口的 Stu1 类,定义姓名、年龄、性别 3 个属性和包含这 3个参数的构造方法,在实现接口的 printInfo()方法中输出所有属性信息。程序代码如下

[java]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. package com.linbingwen;

  2. public class Stu1 implements Student {

  3. private String name;

  4. private String sex;

  5. private int age;

  6. public Stu1(String name, String sex, int age) {

  7. super();

  8. this.name = name;

  9. this.sex = sex;

  10. this.age = age;

  11. }

  12. public void printInfo() {

  13. System.out.println("姓名:" + name);

  14. System.out.println("年龄:" + age);

  15. System.out.println("性别:" + sex);

  16. }

  17. }

( 3 ) applicationContext.xml 是 装 配 JavaBean 的 配 置 文 件 , 它 通 过 3 个标签为构造方法传递两个 String 类型和一个 int 类型的参数。程序代
码如下。

[html]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3. xmlns:p="http://www.springframework.org/schema/p"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd"\>
  5. <bean id="stu1" class="com.linbingwen.Stu1">
  6. <constructor-arg>
  7. <value>飞龙</value>
  8. </constructor-arg>
  9. <constructor-arg>
  10. <value>男</value>
  11. </constructor-arg>
  12. <constructor-arg>
  13. <value>26</value>
  14. </constructor-arg>
  15. </bean>
  16. </beans>

注意:这里要把applicationContext.xml放在src文件夹下。添加Spring和包不懂看这里
(4)创建 Info 类。它是实例的主类,负责载入容器,从容器中获得 Stu1 类的实例,并调用 Stu1 类的 pringInfo()方法打印学生信息。程序代码如下

[java]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. package com.linbingwen;

  2. import org.springframework.context.ApplicationContext;

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

  4. public class Info {

  5. public static void main(String[] args) {

  6. ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

  7. Student student = (Student) applicationContext.getBean("stu1");

  8. student.printInfo();

  9. }

  10. }

实例运行结果如图 所示。

Spring学习总结(5)——IOC注入方式总结

        通过这个实例,可以看到容器通过多个标签完成了对构造方法的传参,但是如果标签的赋值顺序与构造方法中参数的顺序或参数类型不同,程序会产生异常。标签可以使用“index”属性和“type”属性解决此类问题。下面分别介绍这两个属性的用法。
type 属性:可以指定参数类型以确定要为构造方法的哪个参数赋值。当需要赋值的属性在构造方法中没有相同的类型时,可以使用这个参数。因此实例中 stu1 的配置信息可以
这样写:

[html]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
  3. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd"\>
  4. <bean id="stu1" class="com.linbingwen.Stu1">
  5. <constructor-arg>
  6. <value>飞龙</value>
  7. </constructor-arg>
  8. <constructor-arg>
  9. <value>男</value>
  10. </constructor-arg>
  11. <constructor-arg type="int">
  12. <value>26</value>
  13. </constructor-arg>
  14. </bean>
  15. </beans>

index 属性: 用于指定构造方法的参数索引,指定当前标签为构造方法的那个参数赋值。因为程序中含有两个 String 类型的参数,type 属性无法做判断,
导致 name 和 sex 参数无法判断正确性。这时需要设置 index 属性定义赋值索引来指定构造方法的参数位置。修改后的 applicationContext.xml 配置文件内容如下。

[html]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
  3. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd"\>
  4. <bean id="stu1" class="com.linbingwen.Stu1">
  5. <constructor-arg index="0">
  6. <value>飞龙</value>
  7. </constructor-arg>
  8. <constructor-arg index="1">
  9. <value>男</value>
  10. </constructor-arg>
  11. <constructor-arg type="int">
  12. <value>26</value>
  13. </constructor-arg>
  14. </bean>
  15. </beans>

在修改后的代码中,两个 String 类型的参数通过“index”属性指定了在构造方法中的位置,确保了传参的正确性,第 3 个标签的 type 属性可以改写成
“index=2”。现在的 3 个标签可以随意调换顺序而不会影响到构造方法的正确赋值。标签还有“ref”和“value”两个属性,分别用于引用其他 JavaBean和定义新值。由于使用构造方法在配置文件中定义 JavaBean 使用得不多,所以这两个属性不再介绍。

二、设值注入

一个简单的 JavaBean 最明显的规则就是以一个私有属性对应 set()和 get()方法,来实现对属性的封装。既然 JavaBean 有 set()方法来设置 Bean 的属性,Spring 就会有相应的支持。除了为构造方法传递参数的标签之外,标签可以为JavaBean 的 set()方法传递参数,即通过 set()方法为属性赋值。在上面的实例中再添加一个 Moniter 类。

设置 Moniter 类属性和 set()/get()方法。程序代码如下。

[java]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. package com.linbingwen;

  2. public class Moniter implements Student {

  3. private String name;

  4. private String sex;

  5. private int age;

  6. public void printInfo() {

  7. System.out.println("姓名:" + name);

  8. System.out.println("年龄:" + age);

  9. System.out.println("性别:" + sex);

  10. }

  11. public int getAge() {

  12. return age;

  13. }

  14. public void setAge(int age) {

  15. this.age = age;

  16. }

  17. public String getName() {

  18. return name;

  19. }

  20. public void setName(String name) {

  21. this.name = name;

  22. }

  23. public String getSex() {

  24. return sex;

  25. }

  26. public void setSex(String sex) {

  27. this.sex = sex;

  28. }

  29. }

修改 applicationContext.xml 配置文件。添加名称为 Moniter 的 Java Bean 的定义,用标签的“name”属性指定要操作的 JavaBean 的属性,然后通过的子标签为属性赋值。修改后的代码如下。

[html]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. <beans xmlns="http://www.springframework.org/schema/beans"

  2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

  3. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd"\>

  4. <bean id="stu1" class="com.linbingwen.Stu1">

  5. <constructor-arg index="0">

  6. <value>飞龙</value>

  7. </constructor-arg>

  8. <constructor-arg index="1">

  9. <value>男</value>

  10. </constructor-arg>

  11. <constructor-arg type="int">

  12. <value>26</value>

  13. </constructor-arg>

  14. </bean>

  15. <bean id="moniter" class="com.linbingwen.Moniter">

  16. <property name="age">

  17. <value>26</value>

  18. </property>

  19. <property name="name">

  20. <value>欣欣</value>

  21. </property>

  22. <property name="sex">

  23. <value>女</value>

  24. </property>

  25. </bean>

  26. </beans>

程序运行结果如图  所示

Spring学习总结(5)——IOC注入方式总结

三、接口注入(interface injection)

==============================

接口注入指的就是在接口中定义要注入的信息,并通过接口完成注入。

具体步骤如下
①.编写一个接口IBuniness,各种数据库的注入将通过这个接口进行。代码如下

[java]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. package ch3;

  2. public interface IBusiness {

  3. public void createDI(DataBase db);

  4. }

②.任何想要使用数据库实例的类都必须实现这个接口,业务逻辑类Business实现这个接口IBusiness。代码如下

[java]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. package ch3;

  2. public class Business implements IBusiness {

  3. private DataBase db;

  4. @Override

  5. public void createDI(DataBase db) {//接口注入

  6. this.db = db;

  7. }

  8. // 根据注入的数据库,从XXX数据库中取得数据。

  9. public void getData(){

  10. db.getData();

  11. }

  12. }

3.编写测试类TestBusiness。代码如下

[java]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. package ch3;
  2. public class TestBusiness {
  3. private Business business = new Business();
  4. // 根据注入的数据库类,从oracle中取得数据库。
  5. public void getData() {
  6. business.createDI(new OracleDataBase()); // 注入实际的数据库类型。如要变更式样,只需改变此处即可,达到重用目的。
  7. business.getData();
  8. }
  9. }

如果要完成依赖关系注入的对象,必须实现IBusiness接口。

四、JavaBean 的赋值标签

以上只介绍了如何用标签赋值,那么复杂的属性如何赋值呢?例如 Null、对象引用、集合类等。接下来将要介绍对 JavaBean 的复杂属性赋值的标签,它们可以应用到
任何如可以给 JavaBean 的属性赋值的标签中。
1.标签
这是一个普通的赋值标签,可直接在成对的标签中放入数值或其他赋值标签,Spring 会把这个标签提供的属性值注入到指定的 JavaBean 中。语法格式如下。

[html]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. <value>arg</value>

arg:传递给 JavaBean 的属性值。
2.标签
这个标签可以引用其他 JavaBean 的实例对象,当传递的参数是其他 JavaBean 的实例对象时使用此标签。语法格式如下。

[html]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. <ref bean="JavaBean"/>

bean:指定引用的 JavaBean。
3.标签
这是为 JavaBean 赋 Null 空值的标签。当 JavaBean 的某个属性暂不使用,要将其设置为 Null 值时使用此标签。语法格式如下。

[html]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

[html]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. <null></null>

4.标签
这是为 List 集合类或数组赋值的标签。当 JavaBean 的某个属性是 List 集合类型或数组时,需要使用此标签为 List 集合类型或数组的每一个元素赋值。语法格式如下。

[html]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. <list>
  2. <value>arg1</value>
  3. <value>arg2</value>
  4. </list>

:赋值标签,为标签指定的属性赋值。也可以使用其他赋值标签作为集合类赋值标签的子标签,例如或 3.2.7 节中介绍的使用标签定义匿名内部
JavaBean 的方法。此标签应用在标签中定义 JavaBean 的完整代码举例如下。

[html]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. <bean id="school" class="School">
  2. <property name="studentList">
  3. <list>
  4. <ref bean=" student1"/>
  5. <value>student2</value>
  6. </list>
  7. </property>
  8. </bean>

5.标签
标签类似,标签也是为集合对象赋值,不过赋值的对象是 Set 类型的属性。语法格式如下。

[html]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. <set>
  2. <ref bean="arg1"/>
  3. <value>arg2</value>
  4. ……
  5. </set>

此标签应用在标签中定义 JavaBean 的完整代码举例如下

[html]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. <bean id="school" class="School">
  2. <property name="student">
  3. <set>
  4. <ref bean=" student1"/>
  5. <value>name</value>
  6. </set>
  7. </property>
  8. <bean>

6.标签
此标签为 Map 集合赋值。因为 Map 以键值对(key/value)的方式存放数据,所以需要使用子标签装载 key 与 value 数据。Map 集合的 key 可以是任何类型的对象,而标签的属性 key 是以 String 类型表示的,所以限制了 Spring 中 Map 的 key 只能用 String 来表示。语法格式如下。

[html]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. <map>
  2. <entry key="key1">
  3. <ref bean="arg1" />
  4. </entry>
  5. </map>

标签的子标签,其“key”属性用于指定 Map 集合类的键值(key)。此标签应用在标签中定义 JavaBean 的完整代码举例如下。

[html]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. <bean id="school" class="School">
  2. <property name="student">
  3. <map>
  4. <entry key="key1">
  5. <ref bean=" student1" />
  6. </entry>
  7. <entry key="key2">
  8. <value> student2</value>
  9. </entry>
  10. </map>
  11. </property>
  12. </bean>

7.标签
这是为 java.util.Properties 类型属性赋值的标签,和标签类似,但是它的(key/value)键值全都是 String 类型的,无法赋予 Object 对象类型。语法格式如下。

[html]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. <props>
  2. <prop key="key1">value</prop>
  3. </props>

的子标签,其“key”属性用于指定 Properties 类的键值(key)。此标签应用在标签中定义 JavaBean 的完整代码举例如下。

[html]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. <bean id="school" class="School">
  2. <property name="student">
  3. <props>
  4. <prop key="key1">student1</prop>
  5. <prop key="key2">student2</prop>
  6. </props>
  7. </property>
  8. </bean>

8 匿名内部 JavaBean 的创建
通过前面的介绍,读者应该对如何使用 XML 装配 JavaBean 有了一定的了解。但是编程中经常遇到匿名的内部类,在 Spring 中该如何利用 XML 装配呢?其实非常简单,在需要匿名内部类的地方直接用标签定义一个内部类即可。如果要使这个内部类匿名,可以不指定标签的 id 或 name 属性。例如下面这段代码:

[html]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. <bean id="school" class="School">
  2. <property name="student">
  3. <bean class="Student"/>
  4. </property>
  5. </bean>

代码中定义了匿名的 Student 类,将这个匿名内部类赋给了 school 类的实例对象。

五、 list、set、map注入使用范例

还是接上面的工程,新建一个School.java,代码如下:

[java]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. package com.linbingwen;

  2. import java.util.Iterator;

  3. import java.util.List;

  4. import java.util.Map;

  5. import java.util.Set;

  6. public class School {

  7. private List listStu;

  8. private Set setStu;

  9. private Map mapStu;

  10. public List getListStu() {

  11. return listStu;

  12. }

  13. public void setListStu(List listStu) {

  14. this.listStu = listStu;

  15. }

  16. public Set getSetStu() {

  17. return setStu;

  18. }

  19. public void setSetStu(Set setStu) {

  20. this.setStu = setStu;

  21. }

  22. public Map getMapStu() {

  23. return mapStu;

  24. }

  25. public void setMapStu(Map mapStu) {

  26. this.mapStu = mapStu;

  27. }

  28. public void printSchool(){

  29. System.out.println("--------list--------");

  30. for (int i = 0; i < listStu.size(); i++) {

  31. System.out.println(listStu.get(i));

  32. }

  33. System.out.println("--------set--------");

  34. for(Object s : setStu){

  35. System.out.println(s);

  36. }

  37. System.out.println("--------map--------");

  38. Iterator it=mapStu.entrySet().iterator();

  39. System.out.println(mapStu.entrySet().size());

  40. String key;

  41. String value;

  42. while(it.hasNext()){

  43. Map.Entry entry = (Map.Entry)it.next();

  44. key=entry.getKey().toString();

  45. value=entry.getValue().toString();

  46. System.out.println(key+"===="+value);

  47. }

  48. }

  49. }

applicationContext.xml如下:

[java]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. <beans xmlns="http://www.springframework.org/schema/beans"

  2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

  3. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd"\>

  4. <bean id="stu1" name="student1" class="com.linbingwen.Stu1">

  5. <constructor-arg index="0">

  6. 飞龙

  7. <constructor-arg index="1">

  8. <constructor-arg type="int">

  9. 26

  10. <bean id="moniter" name="student2" class="com.linbingwen.Moniter">

  11. <property name="age">

  12. 26

  13. <property name="name">

  14. 欣欣

  15. <property name="sex">

  16. <bean id="school" class="com.linbingwen.School">

  17. <property name="listStu">

  18.   

  19.   

  20.      

  21. <bean class="com.linbingwen.Moniter"> 

  22. 1

  23. hello

  24. <property name="setStu">

  25.   

  26.      

  27.      

  28. <bean class="com.linbingwen.Stu1"> 

  29. <constructor-arg value="大平" index="0">

  30. <constructor-arg value="男" index="1">

  31. <constructor-arg value="10" index="2">

  32. 333333

  33. Evankaka

  34. <property name="mapStu">

  35. <entry key="key1">

  36.   

  37. <entry key="key2">

  38. <bean class="com.linbingwen.Moniter"> 

  39. <entry key="key3">

  40. student2

  41. <entry key="key4">

  42. 56

如下:

[java]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. package com.linbingwen;

  2. import org.springframework.context.ApplicationContext;

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

  4. public class Info {

  5. public static void main(String[] args) {

  6. ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

  7. Student student = (Student) applicationContext.getBean("stu1");

  8. student.printInfo();

  9. Student moniter = (Student) applicationContext.getBean("moniter");

  10. moniter.printInfo();

  11. School school=(School) applicationContext.getBean("school");

  12. school.printSchool();

  13. }

  14. }

输出结果:

四月 02, 2015 5:36:38 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@addb54: startup date [Thu Apr 02 17:36:38 CST 2015]; root of context hierarchy
四月 02, 2015 5:36:38 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [applicationContext.xml]
四月 02, 2015 5:36:38 下午 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
信息: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@ebcd03: defining beans [stu1,moniter,school]; root of factory hierarchy
姓名:飞龙
年龄:26
性别:男
姓名:欣欣
年龄:26
性别:女
--------list--------
姓名:欣欣;年龄:26;性别:女
姓名:欣欣;年龄:26;性别:女
姓名:飞龙;年龄:26;性别:男
姓名:阿屁;年龄:20;性别:男
1
hello
--------set--------
姓名:欣欣;年龄:26;性别:女
姓名:飞龙;年龄:26;性别:男
姓名:大平;年龄:10;性别:男
333333
Evankaka
--------map--------
4
key1====姓名:欣欣;年龄:26;性别:女
key2====姓名:小王;年龄:80;性别:男
key3====student2
key4====56

六、 总结

 设值注入和构造注入的比较

1、设值注入的优点

(1)与传统的JavaBean的写法更相似,更容易让人理解,依赖关系显得更加直观、自然。

(2)对于复杂的依赖关系,如果采用构造注入会导致构造器过于臃肿,难以阅读。因为Spring在创建Bean实例时,需要同时实例化其依赖的全部实例,因而导致Struts+Spring+Hibernate整合开发性能下降。设值注入可以避免这些问题。

(3)在某些属性可选的情况下,多参数的构造器更加笨重。

2、构造注入的优点

(1) 可以在构造器中决定依赖关系的注入顺序。例如,组件中其他依赖关系的注入,常常需要依赖于Datasource的注入。采用构造注入时,可以在代码中清晰地决定注入顺序,优先依赖先注入。

(2)对于依赖关系无须变化的bean,构造注入更有用处。因为没有setter,所有的关系都在构造器中设定,因此无需担心后续代码对依赖关系产生破坏。

(3) 依赖关系只能在构造器中设定,因为只有组件的创建者才能改变组件的依赖关系。对于组件的调用者而言,组件内部的依赖关系完全透明,更符合高内聚的原则。

建议采用设值注入为主,构造注入为辅的注入策略。

Spring Bean的其他说明

1、 Bean的标识(id,name,class)

id:bean的唯一标识。

2、name:bean的别名,可以有多个。

class:bean的具体实现类

3、 Bean的作用域

(1) singleton:单例,在IOC容器里只有一个实例

[html]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. <beanidbeanid="loginAction"class="net.vzhang.spring3.action.LoginAction" scope="singleton"/>

(2) prototype:

[html]  view plain copy Spring学习总结(5)——IOC注入方式总结  Spring学习总结(5)——IOC注入方式总结

  1. <beanidbeanid="loginAction2"class="net.vzhang.spring3.action.LoginAction2" scope="prototype"/>

request:针对Web应用的每次请求都生成一个新的实例

每次对bean请求时,都会创建一个新的实例。

对bean的请求:将其注入到另外一个bean中,或者调用BeanFactory的getBean方法。

session:HttpSessio

点赞
收藏
评论区
推荐文章
blmius blmius
3年前
MySQL:[Err] 1292 - Incorrect datetime value: ‘0000-00-00 00:00:00‘ for column ‘CREATE_TIME‘ at row 1
文章目录问题用navicat导入数据时,报错:原因这是因为当前的MySQL不支持datetime为0的情况。解决修改sql\mode:sql\mode:SQLMode定义了MySQL应支持的SQL语法、数据校验等,这样可以更容易地在不同的环境中使用MySQL。全局s
皕杰报表之UUID
​在我们用皕杰报表工具设计填报报表时,如何在新增行里自动增加id呢?能新增整数排序id吗?目前可以在新增行里自动增加id,但只能用uuid函数增加UUID编码,不能新增整数排序id。uuid函数说明:获取一个UUID,可以在填报表中用来创建数据ID语法:uuid()或uuid(sep)参数说明:sep布尔值,生成的uuid中是否包含分隔符'',缺省为
待兔 待兔
3个月前
手写Java HashMap源码
HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程22
Jacquelyn38 Jacquelyn38
3年前
2020年前端实用代码段,为你的工作保驾护航
有空的时候,自己总结了几个代码段,在开发中也经常使用,谢谢。1、使用解构获取json数据let jsonData  id: 1,status: "OK",data: 'a', 'b';let  id, status, data: number   jsonData;console.log(id, status, number )
Stella981 Stella981
3年前
KVM调整cpu和内存
一.修改kvm虚拟机的配置1、virsheditcentos7找到“memory”和“vcpu”标签,将<namecentos7</name<uuid2220a6d1a36a4fbb8523e078b3dfe795</uuid
Wesley13 Wesley13
3年前
mysql设置时区
mysql设置时区mysql\_query("SETtime\_zone'8:00'")ordie('时区设置失败,请联系管理员!');中国在东8区所以加8方法二:selectcount(user\_id)asdevice,CONVERT\_TZ(FROM\_UNIXTIME(reg\_time),'08:00','0
Wesley13 Wesley13
3年前
00:Java简单了解
浅谈Java之概述Java是SUN(StanfordUniversityNetwork),斯坦福大学网络公司)1995年推出的一门高级编程语言。Java是一种面向Internet的编程语言。随着Java技术在web方面的不断成熟,已经成为Web应用程序的首选开发语言。Java是简单易学,完全面向对象,安全可靠,与平台无关的编程语言。
Stella981 Stella981
3年前
Django中Admin中的一些参数配置
设置在列表中显示的字段,id为django模型默认的主键list_display('id','name','sex','profession','email','qq','phone','status','create_time')设置在列表可编辑字段list_editable
Wesley13 Wesley13
3年前
MySQL部分从库上面因为大量的临时表tmp_table造成慢查询
背景描述Time:20190124T00:08:14.70572408:00User@Host:@Id:Schema:sentrymetaLast_errno:0Killed:0Query_time:0.315758Lock_
Python进阶者 Python进阶者
9个月前
Excel中这日期老是出来00:00:00,怎么用Pandas把这个去除
大家好,我是皮皮。一、前言前几天在Python白银交流群【上海新年人】问了一个Pandas数据筛选的问题。问题如下:这日期老是出来00:00:00,怎么把这个去除。二、实现过程后来【论草莓如何成为冻干莓】给了一个思路和代码如下:pd.toexcel之前把这