JavaConfig实现配置

2022-02-09

JavaConfig实现配置

如果我们使用JavaConfig实现配置，那么我们就不需要使用xml文件对Spring进行配置了；

JavaConfig进行配置时和注解配合使用的

JavaConfig的使用过程

创建一个javaConfig类
用@Configuation注解表示该类是我们的JavaConfig类

武装到牙齿的config类

package com.dwx.config;


import com.dwx.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.dwx.pojo")
public class DwxConfig {

    @Bean
    public User getUser(){
        return new User();
    }
}

注解分析：

@Configuration:表示我们这个类类似于xml文件
@ComponentScan("包名"):表示原来xml中的<context:ComponentScan base-package="包名">
@Bean:表示<bean id="" class=""/>其中这个方法的方法名是bean的id,返回值类型表示bean的class

我们使用注解包装的pojo

package com.dwx.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class User {
    @Value("dwx")
    private String name;

    public User(String name) {
        this.name = name;
    }

    public User() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

我们的测试类：

import com.dwx.config.DwxConfig;
import com.dwx.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MtTest {
    public static void main(String[] args) {
       ApplicationContext context = new AnnotationConfigApplicationContext(DwxConfig.class);
        User getUser = (User) context.getBean("getUser");
        System.out.println(getUser);
    }
}

注意：因为我们彻底的摆脱了xml配置，因此在获取contest时，我么使用的是：

new AnnotationConfigApplicationContext(XXConfig.class)

其中他的参数是一个class类即我们的config的class属性

bean的id就是我们的方法名

Bean的自动装配

2022-02-09

Bean的自动装配

bean自动装配的特点：

自动装配是spring满足bean依赖的一种方式
Spring会在上下文中自动寻找并自动给bean装配属性

在Spring中有三种装配的方式

在xml中显示的装配
在java中显示的装配
隐式的自动装配

其中在xml中显示的装配是我们之前就开始学的。

我们搭建一个环境：一个人有两只宠物来以此为案例讲解隐式的自动装配

第一只宠物Dog

package com.dwx.pojo;

public class Dog {
    //对于一个宠物 我们只要求它会叫
    public void shoot(){
        System.out.println("汪汪队立大功");
    }

    @Override
    public String toString() {
        return "Dog{}";
    }
}

第二只宠物Cat

package com.dwx.pojo;

public class Cat {
    //对于一个宠物 我们只要求它会叫
    public void shoot(){
        System.out.println("喵喵队闯大祸");
    }

    @Override
    public String toString() {
        return "Cat{}";
    }
}

主人

package com.dwx.pojo;

public class Person {
    //对于一个人 他有自己的基本属性以及一只猫一只狗
    private String name;
    private int id;
    private Dog dog;
    private Cat cat;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public Person(String name, int id, Dog dog, Cat cat) {
        this.name = name;
        this.id = id;
        this.dog = dog;
        this.cat = cat;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", dog=" + dog +
                ", cat=" + cat +
                '}';
    }

    public Person() {
    }
}

当时用手动装配

当时用手动装配我们的xml就会是这样的

<?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="cat" class="com.dwx.pojo.Cat"/>
        <bean id="dog" class="com.dwx.pojo.Dog"/>
        <!--装配我们的操作对象-->
        <bean id="person" class="com.dwx.pojo.Person">
            <property name="name" value="dwx"/>
            <property name="id" value="123456"/>
            <property name="cat" ref="cat"/>
            <property name="dog" ref="dog"/>
        </bean>


</beans>

当使用自动装配

所谓的自动装配就是不用再去自己写property等的参数了，只需要在<bean/>中加上autowire=""这个参数即可

自动装配也不止一种，而且各有各的局限性

当使用`ByName`自动装配

<bean id="person" class="com.dwx.pojo.Person" autowire="byName">
           <property name="name" value="dwx"/>
          <property name="id" value="123456"/>
 </bean>

赋值还是需要用<property>，但是对于引用类型的匹配已经不用我们自己去匹配了

但是byName的局限性就是，我们在Person中的参数名字必须和我们引用类型注册的id一致，否则将找不到。

当使用`ByType`自动装配

<bean id="person" class="com.dwx.pojo.Person" autowire="byType">
                 <property name="name" value="dwx"/>
                <property name="id" value="123456"/>
             </bean>

局限性在于，如果两个参数的类型是相同的，就不能用这种装配方式

当使用注解装配

使用注解装配有两种注解@Autowired和@Resource

两者的区别：

@Autowired是先执行byType查找，如果出现两种以上的类型采用byName
@Resource是先执行byName查找，当找不到时才是用byType查找

两者使用时的共同特点：

要现在xml中进行装配
要使用时在xml体中使用<context:annotation-config/>

修改后的xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

   
</beans>

xml的使用

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd"
>

    <context:annotation-config/>
    <!--首先装配我们的引用类型-->
    <bean id="cat" class="com.dwx.pojo.Cat"/>
    <bean id="dog" class="com.dwx.pojo.Dog"/>
    <bean id="person" class="com.dwx.pojo.Person">
        <property name="name" value="dwx"/>
        <property name="id" value="123456"/>
    </bean>


</beans>

注解添加的位置

两种注解添加的位置都一样，要不是在需要进行注解的元素上，要不在set方法上

如果在元素上加上注解，这个元素就不用写其对应的set方法了

使用注解的例子:

package com.dwx.pojo;

import org.springframework.beans.factory.annotation.Autowired;

public class Person {
    //对于一个人 他有自己的基本属性以及一只猫一只狗
    private String name;
    private int id;
    @Autowired
    private Dog dog;
    @Autowired
    private Cat cat;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public Person(String name, int id, Dog dog, Cat cat) {
        this.name = name;
        this.id = id;
        this.dog = dog;
        this.cat = cat;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", dog=" + dog +
                ", cat=" + cat +
                '}';
    }

    public Person() {
    }
}
package com.dwx.pojo;

import org.springframework.beans.factory.annotation.Autowired;

public class Person {
    //对于一个人 他有自己的基本属性以及一只猫一只狗
    private String name;
    private int id;
    @Autowired
    private Dog dog;
    @Autowired
    private Cat cat;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public Person(String name, int id, Dog dog, Cat cat) {
        this.name = name;
        this.id = id;
        this.dog = dog;
        this.cat = cat;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", dog=" + dog +
                ", cat=" + cat +
                '}';
    }

    public Person() {
    }
}

依赖注入环境（DI）

2022-02-08

依赖注入环境（DI）

依赖注入是Spring除IOC以外的另一个重点

依赖注入有三种方式：

构造器注入
set注入
拓展注入

构造器注入

IOC创建对象的过程 | dwx-tx的小天地

这是之前的笔记就是讲的构造器注入

set注入

set注入是依赖注入的重点

依赖和注入是两个过程，需要分开理解

依赖：bean对象的创建依赖于容器
注入：bean对象中的所有属性由容器来注入

为了方便理解注入的过程以及了解所有的类型的注入方法，我们引出下边这个复杂的例子：

{环境搭建}：

搭建一个复杂的实体类，其中的参数包括：

基本数据类型
引用数据类型
List[]
数组
map
set<>
Properties

package com.dwx.pojo;

import java.util.*;

public class Student {
    //创建一个复杂的实体类
    private String name;
    //引用类型
    private Address address;
    //数组
    private String[] books;
    //list
    private List<String> hobbys;
    //map
    private Map<String,String> card;
    //set
    private Set<String> games;
    //可以赋值为null的参数
    private String wife;
    //properties
    private Properties info;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String[] getBooks() {
        return books;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public List<String> getHobbys() {
        return hobbys;
    }

    public void setHobbys(List<String> hobbys) {
        this.hobbys = hobbys;
    }

    public Map<String, String> getCard() {
        return card;
    }

    public void setCard(Map<String, String> card) {
        this.card = card;
    }

    public Set<String> getGames() {
        return games;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public String getWife() {
        return wife;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    public Properties getInfo() {
        return info;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address +
                ", books=" + Arrays.toString(books) +
                ", hobbys=" + hobbys +
                ", card=" + card +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }
}

Address引用类型:

package com.dwx.pojo;

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Address{" +
                "address='" + address + '\'' +
                '}';
    }
}

到xml中去进行整合配置注入

xml中注入这些复杂类型

基本数据类型和String的注入

直接使用<properties name=" " value=" "/>来给参数进行注入(类似于赋值)

引用类型的注入

对于引用类型，先在bean中2进行注册，在通过ref来注入

<bean id="address" class="com.dwx.pojo.Address">
      <!--为我们这个引用类型赋值-->
      <property name="address" value="河南省新乡市"/>
  </bean>

 <!--对我们复杂的实体类进行注入-->
  <bean id="student" class="com.dwx.pojo.Student">
      <property name="address" ref="address"/>
  </bean>

数组的注入

<!--数组的注入-->
      <property name="books">
          <array>
              <value>《百年孤独》</value>
              <value>《白鹿原》</value>
              <value>《生死疲劳》</value>
              <value>《挪威的森林》</value>
          </array>
      </property>

List的注入

<!--List的注入-->
       <property name="hobbys">
           <list>
               <value>跑步</value>
               <value>听音乐</value>
               <value>阅读</value>
           </list>
       </property>

map的注入

<!--map的注入-->
        <property name="card">
            <map>
                <entry key="身份证" value="123123123"/>
                <entry key="银行卡" value="345345123"/>
                <entry key="一卡通" value="dasd445645"/>
            </map>
        </property>

key:value相当于键值对

set的注入

<!--set的注入-->
       <property name="games">
           <set>
               <value>英雄联盟</value>
               <value>战意</value>
               <value>辐射</value>
           </set>
       </property>

给参数注入空值

1	<property name="wife" value=""/>

或者写成

1
2
3

<property name="">
    <value>null</value>
</property>

Properties注入

property name="info">
            <props>
                <prop key="name">dwx</prop>
                <prop key="id">2008114063</prop>
                <prop key="age">20</prop>
            </props>
        </property>

相当于键值对，key就是但是value在<prop></prop>之间

输出结果：

Student{name='dwx', address=Address{address='河南省新乡市'}, books=[《百年孤独》, 《白鹿原》, 《生死疲劳》, 《挪威的森林》], hobbys=[跑步, 听音乐, 阅读], card={身份证=123123123, 银行卡=345345123, 一卡通=dasd445645}, games=[英雄联盟, 战意, 辐射], wife='null', info={name=dwx, id=2008114063, age=20}}

c命令注入和p命令注入

c命令对应constructor-arg，是对构造器注入的简化

p命令对应property，是对set注入的简化

P命令注入

p命令对应property，是对set注入的简化

P命令在使用前需要在xml文件的头文件中加上一个配置

xmlns:c="http://www.springframework.org/schema/c"

加完配置后的xml文件像这样

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

P命令的使用

1	<bean id="user" class="com.dwx.pojo.User" p:name="dwx" p:age="18"/>

使用时就用P:参数名=""就可以使用了

c命令注入

c命令对应constructor-arg，是对构造器注入的简化

c命令在使用前需要在xml文件的头文件中加上一个配置

xmlns:c="http://www.springframework.org/schema/c"

加完配置后的xml文件像这样

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

C命令的使用：

<bean id="user2" class="com.dwx.pojo.User" c:age="19" c:name="ddd"/>

使用时就用c:参数名=""就可以使用了

OC创建对象的过程

2022-02-08

IOC创建对象的过程

我们可以看到当我们使用了spring时，我们就不用再使用new来创建对象了。那是因为有spring自动帮我们创建对象，IOC是通过构造器创建对象的，因此由于构造器有两种之分因此创建对象的方式也有两种。

无参构造器创建对象

此时的pojo层

package com.pojo;

public class User {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public User() {
        System.out.println("这里使用的是无参构造器");
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

此时的xml

<?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">

    <!--整合pojo层-->
    <!--当使用的是无产构造器时-->
    <bean name="user" class="com.pojo.User">
        <property name="name" value="dwx"/>
    </bean>

</beans>

此时的测试类

import com.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        //测试spring容器
        //转换成更高级的类型
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean("user");
        System.out.println(user);
    }
}

测试结果

1
2
3

这里使用的是无参构造器
User{name='dwx'}

使用有参构造创建对象

有参构造的核心就是在创建时需要传入参数，而在spring中，传参的过程有有三种，因此有参构造创建对象的方法又可以分为三种

通过下标创建对象

<constructor-arg index="" value=""/>

注意：下标是从0开始的

此时的xml

<!--当使用有产构造时-->
   <bean name="user" class="com.pojo.User">
       <constructor-arg index="0" value="dwx"/>
   </bean>

通过类型来创建对象

<constructor-arg type="" value=""/>

注意：type如果是基本类型用基本类型，如果是引用类型用引用类型的全路径

此时的xml

<!--类型传值法-->
   <bean name="user" class="com.pojo.User">
       <constructor-arg type="java.lang.String" value="dwx"/>
   </bean>

注意：这个方法具有局限性，如果一个pojo类中有两个参数的类型相同，这种方法就没有作用了。

通过名字创建对象

<construcuctor-arg name="" value=""/>

此时的xml

<!--通过名字传值-->
  <bean name="user" class="com.pojo.User">
      <constructor-arg name="name" value="dwx"/>
  </bean>

很明显，这个方法是最简单的最好用的

当然，使用到复杂类型时也可以先注册在使用ref来使用

有意思

有意思的是，如果一个beans.xml里有多个以及整合好的pojo类

在实例化contest时，其实他们都被实例化了

1
2
3

student的无参构造器
我叫dwx
User{name='dwx'}

Spring配置

2022-02-08

Spring配置

Spring的配置并不多，学起来也不麻烦

别名（alias）

<alias name="" alias=""/>

元素分析：

name指需要起别名的bean的名字
alias指这个bean的别名

被起过别名的bean通过原名和别名都可以调用

bean的配置

spring的配置很少，但是作为spring的核心，bean的配置却很多。这里仅仅介绍bean的经常用到的配置

bean的配置

配置	作用
id	bean的唯一标识符
class	bean对应的对象的全限名称（包名+类名）
name	bean的别名，可以有多个，只要使用`,`或`空格`或者`;`隔开即可

import

import常见于团队开发，可以把多个配置文件整合到一个xml中

<import resource="xx.xml"/>

HelloSpring

2022-02-07

HelloSpring

下边通过一个简单的HelloSpring程序来感受Spring框架的优点吧！

Spring整合POJO层的数据

步骤：

搭建完整的pojo层

package com.pojo;

public class Hello {
    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

在resource中创建一个beans.xml文件

配置文件中的格式可以在官方文档中找到

<?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">

  

</beans>

将pojo包下的类整合到配置文件中

使用<properties/>来给实体类中的参数赋值

<?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="hello" class="com.pojo.Hello">        <property name="str" value="Spring"/>    </bean></beans>

编写测试类

测试类

此时的测试类在调用pojo成时，就不用再去实例化对象，只需要调用Spring容器即可

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

使用这个context中的getBean("bean的id")这个方法就能调用到一个对象

理论分析

1
2
3

<bean id="hello" class="com.pojo.Hello">
       <property name="str" value="Spring"/>
</bean>

这里的<bean></bean>就可以视为是对对象实例化的过程
id代表这个对象的名字
class代表这个对象的类
<properties/>这里表示赋值的过程name表示参数的名字，value表示付给参数的值

Spring整合Dao层

编写Dao抽象类以及他的实体类

对实体类进行整合（也是在beans.xml中进行整合的）

1 2	<bean id="MyBtais" class="dao.MybatisUserDaoImp"/> <bean id="User" class="dao.UserDaoImp"/>

Spring整合Service层

编写Service层的抽象类以及他的所有的实现类
对实体类进行整合(bean.xml中)

由于我们那个IOC思想是service可以调用多个Dao，因此这里使用注册好的Dao

<!--注册好和Dao--> 
<bean id="MyBtais" class="dao.MybatisUserDaoImp"/>
    <bean id="User" class="dao.UserDaoImp"/>   
<!--因为我们为了满足IOC原则 对userDao进行赋值-->
<!--此处使用ref 而不是 value value表示一个值-->
<!--而此时我们的ref表示已经注册过得bean的id-->
   <bean id="UserService" class="service.UserServiceImp">
        <property name="userDao" ref="MyBtais"/>
    </bean>

编写测试类

同理只要是通过Spring整合的，只用Spring的容器就能解决变量实例化的过程

public static void main(String[] args) {
       ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
       UserService userService = (UserService) context.getBean("UserService");
       userService.getUser();

   }

需要注意的是，我们这里有一个很明显的强制转型，如果没有转型，系统默认得到的userService是object类型，这样我们就不能调用想要的方法了

注意手动去进行强转

这样，我们的代码就再也不用改变了，只需要用户改变配置文件即可

Spring预科

2022-02-07

spring预科

spring也是一种框架，mybatis框架是作用于永久层，但是spring是作用于其他的地方的。

spring中文文档

Spring Framework 中文文档 - Core Technologies | Docs4dev

spring的优点

spring是一个开源的免费的开源容器
spring是一个轻量级的，非入侵的框架
spring控制翻转，面向切面编程
支持事务处理（jdbc），对框架整合的支持

spring的依赖

spring需要导两种包：Spring webmvc和Spring jdbc

首先Spring webmvc是一个整合了很多spring用到的包

Spring jdbc是用于与mybatis整合是需要的包

<dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-webmvc</artifactId>
           <version>5.3.15</version>
       </dependency>
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-jdbc</artifactId>
           <version>5.3.15</version>
       </dependency>

IOC理论推导

在之前的约我中，如果用户的需求发生了改变，我们就要去修改源代码，但是这种事情处理起来很复杂。如果我们把代码的改变权交给用户，我们就能减少很多的事务。

我们引出下面的实例来解释我们的思想

Dao层结构

由上图我们可以看到这个抽象结构有两个实现类，但是在service层调用时，我们只需要调用一个

package service;

import dao.MybatisUserDaoImp;
import dao.UserDao;
import dao.UserDaoImp;

public class UserServiceImp implements UserService{
    UserDao userDao =  new MybatisUserDaoImp();
    //UserDao userDao = new UserDaoImp()
    @Override
    public void getUser() {
        userDao.UserList();
    }
}

那么如果用户需要的是不同的service，我们就需要去调整他的UserDao参数。就要去修改源代码。

改变思路：如果我们把UserDao看作一个参数，然后使用set方法实现赋值，那么用户再有其他的要求时，我们就不需要进行大的改动，只需要用户去按要求赋值即可

package service;

import dao.MybatisUserDaoImp;
import dao.UserDao;
import dao.UserDaoImp;

public class UserServiceImp implements UserService{
//    UserDao userDao =  new MybatisUserDaoImp();
//    //UserDao userDao = new UserDaoImp()
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void getUser() {
        userDao.UserList();
    }
}

此时的Test

import dao.MybatisUserDaoImp;
import dao.UserDaoImp;
import service.UserServiceImp;

public class MyTest {
    public static void main(String[] args) {
        UserServiceImp userServiceImp = new UserServiceImp();
        userServiceImp.setUserDao(new MybatisUserDaoImp());
        userServiceImp.getUser();
        userServiceImp.setUserDao(new UserDaoImp());
        userServiceImp.getUser();
    }
}

通过set方法就能按照用户的要求实现不同的效果

IOC本质

IOC是Spring框架的核心，可以使用xml配置，使用注解配置，也可以不配置。

控制反转是一种通过描述（xml或注解）并通过第三方生产或获取特定对现货的方式。在Spring中实现控制反转的是IOC容器，其实现方法是依赖注入（DI）。

梦的解析总括

2022-02-05

梦的解析

最近在看一本名为《梦的解析》的书，恰好我是一个做梦者，几乎每一次睡觉都能做梦。有人说可以通过睡觉做梦的频率来判断一个脑袋是否在思考，这样说的话我的脑袋似乎是一直在思考，但我并没有发现自己有过人之处。我希望通过自己记录每一次的有代表性的梦来实践梦的解析，来判断本书的观点的正确性。

《梦的解析》的介绍

《梦的解析》是由弗洛伊德著作的，这个人是研究心理学绕不开的人物，也是他开创了对梦的科学的解释。在他之前，对梦的解释都是掌握在一群神棍的手中，这些的观点可以概括为：梦境对人的未来是由一定的预测意义的。

因此出现了能够未知未来的人，能够通过梦占卜的人。

他们这些古典派占卜的方式可以分成两种：

象征法
译码法

前人的观点

象征法

用一个可以理解的、在某些方面相似的内容来取代显梦。

局限性在于：对梦的解释会受到译梦者主观的影响，因此要做到能够合理的解梦，需要解梦者和译梦者的配合与交流。

译码法

通过每一个象征对应的关键字译成一个有意义的象征。

局限性在于：这种方法就像是用一个译码本去破解密码，但是每个人的译码本是否是一样的？

《梦的解析》的观点

梦都具有某种意义，即使是一种隐意

做梦实际上就是用来代替某种其他的思想过程，所以我们只有正确揭示出这个代替物，才能发现梦的真实含义。

梦不是一种精神活动，而是利用象征意义告知心理器官的一种肉体过程

（难怪有时我做那些像素极高的梦醒来时会觉得很累）

免责声明

由于我做梦的主观性，对梦中人物的描写可能与现实有出入，因此必须做出免责声明；

梦的解析免责声明 | dwx-tx的小天地

记录梦

我计划记录自己的一些梦，这些记录需要有一定的格式

前言：前言描述做梦前发生的事

主体:

描写梦的细节

解析：对梦中出现的元素进行解析

总结：总结这次解梦的结果

梦的解析免责声明

2022-02-05

免责声明

梦都具有某种意义，即使是一种隐意
梦是潜意识中的欲望
梦具有主观性，如果我的梦中不幸出现了你并且梦中的形象与你大相径庭，但那只是我主关的感受，没有实际意义
梦不是一个整体，是各种元素的集合，如果梦中的人物干了不属于他的事，是因为我的大脑的混乱组合
在解梦时我会尽力去将每一块都分离开

生命钟表

2022-02-04

生命钟表

前几天在进行所谓的算命的时候，我想到了是否自己可以为自己制作一个生命钟表，看看自己在这个世界上到底待机多少天？

理论依据

用户输入自己的时间
可以通过无限循环来保证程序的执行、
通过java语言中的Date类来获得一个当地时间
系统时间减去出生时间就是我的待机时间

代码实践

package com.dwx;

import java.sql.Time;
import java.util.Date;
import java.util.Scanner;

public class LifeClock {
    public static void main(String[] args) {
        //记录个人的出生日期
        //输入时间
        int MyYear;
        int MyMonth;
        int MyDate;
        int MyHour;
        int MyMin;
        int MySecond;
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的生日（不知道的数据填0）");
        System.out.println("格式为(yy mm dd h m s)");
        MyYear = scanner.nextInt();
        MyMonth = scanner.nextInt();
        MyDate = scanner.nextInt();
        MyHour = scanner.nextInt();
        MyMin = scanner.nextInt();
        MySecond = scanner.nextInt();

        Date OldDate = new Date(MyYear-1900, MyMonth, MyDate,MyHour,MyMin,MySecond);


        //两者的差算作年龄
        //通过年份相差获得年
        //通过月份相差获得月
        //通过Day相差获得天
        //****
        //规范化这个过程
        while(true){
            //获得现在的时间
            Date NowDate = new Date();


            int year;
            int month;
            int day;
            int hour;
            int min;
            int sed;

            year = NowDate.getYear()-OldDate.getYear();
            month = NowDate.getMonth()-OldDate.getMonth();
            day = NowDate.getDay()-OldDate.getDay();
            hour = NowDate.getHours()-OldDate.getHours();
            min = NowDate.getMinutes()-OldDate.getMinutes();
            sed = NowDate.getSeconds()-OldDate.getSeconds();

            //对代码健壮性进行处理
            if (sed < 0){
                min= min-1;
                sed = sed+60;
            }
            if (min<0){
                hour = hour-1;
                min = min + 60;
            }
            if (hour<0){
                hour = hour+24;
                day = day-1;
            }

            if (day<0){
                month=month-1;
                day = day+30;
            }
            if (month<0){
                year=year-1;
                month = month+12;
            }
            if (year<0){
                System.out.println("请查看您输入的出生日期!!!");
                break;
            }
            //输出计算结果
            System.out.print(year+"年");
            System.out.print(month+"月");
            System.out.print(day+"日");
            System.out.print(hour+"时");
            System.out.print(min+"分");
            System.out.println(sed+"秒");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException exception) {
                exception.printStackTrace();
            }
        }

    }
}

效果图

JavaConfig实现配置

JavaConfig的使用过程

Bean的自动装配

当时用手动装配

当使用自动装配

当使用ByName自动装配

当使用ByType自动装配

当使用注解装配

xml的使用

依赖注入环境（DI）

构造器注入

set注入

xml中注入这些复杂类型

基本数据类型和String的注入

引用类型的注入

数组的注入

List的注入

map的注入

set的注入

给参数注入空值

Properties注入

c命令注入和p命令注入

P命令注入

c命令注入

IOC创建对象的过程

无参构造器创建对象

使用有参构造创建对象

通过下标创建对象

通过类型来创建对象

通过名字创建对象

有意思

Spring配置

别名（alias）

bean的配置

import

HelloSpring

Spring整合POJO层的数据

测试类

Spring整合Dao层

Spring整合Service层

spring预科

spring中文文档

spring的优点

spring的依赖

IOC理论推导

IOC本质

梦的解析

《梦的解析》的介绍

前人的观点

象征法

译码法

《梦的解析》的观点

免责声明

记录梦

免责声明

生命钟表

理论依据

代码实践

当使用`ByName`自动装配

当使用`ByType`自动装配