Spring

<!--log4j2的依赖-->
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-core</artifactId>
  <version>2.19.0</version>
</dependency>
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-slf4j2-impl</artifactId>
  <version>2.19.0</version>
</dependency>

<?xml version="1.0" encoding="UTF-8"?>

<configuration>

    <loggers>
        <!--
            level指定日志级别，从低到高的优先级：
                ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < OFF
        -->
        <root level="DEBUG">
            <appender-ref ref="spring6log"/>
        </root>
    </loggers>

    <appenders>
        <!--输出日志信息到控制台-->
        <console name="spring6log" target="SYSTEM_OUT">
            <!--控制日志输出的格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3level %logger{1024} - %msg%n"/>
        </console>
    </appenders>

</configuration>

//第一步创建日志记录器对象
//获取TestFirstSpring类的日志记录器对象, 就是说只要是这个类中的代码执行记录日志的话,就输出相关的日志信息
Logger logger = LoggerFactory.getLogger(FirstSpringTest.class);
//第二步 记录日志,根据不同的级别来输出日志
logger.info("我是一条日志消息");
logger.debug("我是一条调试信息");
logge

<bean id="vipDaoBean" class="dao.VipDao"/>
<!--    配置UserDao-->
<bean id="userDaoBean" class="dao.UserDao"/>
<!--    配置UserService-->
<bean id="userServiceBean" class="service.UserService">
    <!--想让spring调用对应的set方法,需要配置property标签-->
    <!--name: set方法名去掉set,再把首字母小写-->
    <!--ref: 指定要注入的bean的id-->
<!--        <property name="mySQLUserDao" ref="userDaoBean"/>-->
    <property name="userDao" ref="userDaoBean"/>
    <!--测试后得知,这里的name本质上不是写属性名,只是建议和属性名一样->等于写属性名-->
<!--        <property name="abc" ref="vipDaoBean"/>-->
</bean>

<bean id="vipDaoBean" class="dao.VipDao"/>
<bean id="userDaoBean" class="dao.UserDao"/>
<bean id="csBean" class="service.CustomerService">
    <!--构造注入-->
    <!--
        index属性指定参数下标，第一个参数是0，第二个参数是1，第三个参数是2，以此类推。顺序无所谓
        ref属性用来指定注入的bean的id
    -->
    <!--指定构造方法的第一个参数,下表是0-->
    <constructor-arg index="0" ref="userDaoBean"/>
    <!--指定构造方法的第一个参数,下表是1-->
    <constructor-arg index="1" ref="vipDaoBean"/>
</bean>

<bean id="csBean2" class="service.CustomerService">
    <!--根据构造方法的参数名,注入-->
    <constructor-arg name="userDao" ref="userDaoBean"/>
    <constructor-arg name="vipDao" ref="vipDaoBean"/>
</bean>

<bean id="csBean3" class="service.CustomerService">
    <!--不指定下标,也不指定参数名,让sopring自己做类型匹配-->
    <!--这种方式实际上是根据类型进行注入的,spring会自动根据类型来判断把ref注入给哪个参数-->
    <constructor-arg ref="vipDaoBean"/>
    <constructor-arg ref="userDaoBean"/>
</bean>

<bean id="orderDaoBean" class="dao.OrderDao"/>
<bean id="orderServiceBean" class="service.OrderService">
    <!--使用ref属性来引入.这就是注入外部bean-->
    <property name="orderDao" ref="orderDaoBean"/>
</bean>

<bean id="orderServiceBean2" class="service.OrderService">
    <property name="orderDao">
        <bean class="dao.OrderDao"/>
    </property>
</bean>

public static boolean isSimpleValueType(Class<?> type) {
    return Void.class != type && Void.TYPE != type && (ClassUtils.isPrimitiveOrWrapper(type) ||         Enum.class.isAssignableFrom(type) || CharSequence.class.isAssignableFrom(type) || Number.class.isAssignableFrom(type) || Date.class.isAssignableFrom(type) || Temporal.class.isAssignableFrom(type) || 
URI.class == type || 
URL.class == type || 
Locale.class == type || 
Class.class == type);
}

<bean id="svtBean" class="bean.SimpleValueType">
    <!--报错了.说2023-12-3这个字符串无法转换成java.util.Date-->
    <!--<property name="birth" value="2023-12-3"/>-->
    <!--如果你硬要把Date当作简单类型的话,使用value赋值的话,这个日期字符串格式有要求Sun Dec 03 17:38:19 CST 2023-->
    <!--在实际开发中,一般不会把Date当作简单类型,虽然他是简单类型-->
    <property name="birth" value="Sun Dec 03 17:38:19 CST 2023"/>
</bean>

<bean id="myDataSourceBean" class="jdbc.MyDataSource">
    <property name="driver" value="com.mysql.jdbc.driver"/>
    <property name="url" value="mysql://localhost:3306/powernode"/>
    <property name="user" value="root"/>
    <property name="password" value="hsp"/>
</bean>

<bean id="clazzBean" class="bean.Clazz">
	<property name="name" value="高三一班"/>
</bean>

<bean id="studentBean" class="bean.Student">
    <!--简单类型.使用value-->
    <property name="name" value="张三"/>
    <!--不是简单类型,使用ref-->
    <property name="clazz" ref="clazzBean"/>
</bean>

<bean id="clazzBean" class="bean.Clazz">
	<!--<property name="name" value="高三一班"/>-->
</bean>

<bean id="studentBean" class="bean.Student">
    <!--简单类型.使用value-->
    <property name="name" value="张三"/>
    <!--不是简单类型,使用ref-->
    <property name="clazz" ref="clazzBean"/>
    <!--级联属性赋值, 如果要使用,
        1. Student类要有getClazz方法
        2. 顺序不能颠倒,如当前例子所示-->
    <property name="clazz.name" value="高三一班"/>
</bean>

<bean id="yuQian" class="bean.QianDaYe">
    <!--注入数组之简单类型-->
    <property name="aiHaos">
        <array>
            <value>抽烟</value>
            <value>喝酒</value>
            <value>吃肥肉</value>
        </array>
    </property>

    <!--注入数组之自定义类型-->
    <property name="girls">
        <array>
            <ref bean="girl1"/>
            <ref bean="girl2"/>
            <ref bean="girl3"/>
        </array>
    </property>
</bean>

<!--注入list-->
<property name="friends">
    <list>
        <value>张三</value>
        <value>李四</value>
        <value>王五</value>
        <value>王五</value>
        <value>王五</value>
        <value>王五</value>
    </list>
</property>

<!--注入map-->
<property name="addrs">
    <set>
        <value>北京</value>
        <value>上海</value>
        <value>深圳</value>
        <value>深圳</value>
        <value>深圳</value>
    </set>
</property>

<!--注入map-->
<property name="phones">
    <map>
        <!--如果key或者value是非简单类型的,使用key-ref或者value-ref-->
        <entry key="110" value="报警电话"/>
        <entry key="120" value="急救电话"/>
        <entry key="119" value="火警电话"/>
    </map>
</property>

<!--注入Properties-->
<property name="properties">
    <props>
        <prop key="driver">com.mysql.jdbc.driver</prop>
        <prop key="url">mysql://localhost:3306/powernode</prop>
        <prop key="user">root</prop>
        <prop key="password">hsp</prop>
    </props>
</property>

<bean id="catBean" class="bean.Cat">
    <!--如果不对属性赋值,属性默认就是空-->
<!--        <property name="name" value="tom"/>-->
    <!--如果写null,相当于把null当做字符串传入了-->
<!--        <property name="name" value="null"/>-->
    <!--如果要手动赋空, 使用null标签-->
<!--        <property name="name">-->
<!--            <null/>-->
<!--        </property>-->

    <!--注入空字符串,value不写内容,自动是空字符串-->
<!--        <property name="name" value=""/>-->
    <!--手动注入空字符串-->
    <property name="name">
        <value/>
    </property>
    <property name="age" value="2"/>
</bean>

<bean id="myMathBean" class="bean.MyMath">
    <!--第一种方案使用实体符号代替-->
	<!--<property name="result" value="2 < 3"/>-->
	<!--<property name="result" value="2 &lt; 3"/>-->

    <!--第二种方案使用<![CDATA[]]>-->
    <!--只能用value标签-->
    <property name="result">
        <value><![CDATA[2 < 3]]></value>
    </property>
</bean>

<?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">
    <!--
        第一步,开启p命名空间xmlns:p="http://www.springframework.org/schema/p"
        第二步,bean中使用p:xx="要注入的值/beanId"
    -->
    <bean id="dogBean" class="bean.Dog" p:name="小花" p:age="2" p:birth-ref="birthBean"/>
    <!--获取当前系统时间-->
    <bean id="birthBean" class="java.util.Date"/>
</beans>

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

    <!--
        第一步,开启c命名空间xmlns:c="http://www.springframework.org/schema/c"
        第二步,使用下标/参数名 ,可以使用非简单类型
			  (bean中使用c:[_0|xx]="要注入的值/beanId")
    -->
<!--    <bean id="peopleBean" class="bean.People" c:_0="homo" c:_1="20" c:_2="false"/>-->
    <bean id="peopleBean" class="bean.People" c:name="LGBT" c:age="20" c:sex="false"/>
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:util="http://www.springframework.org/schema/util"
       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
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
    <!--开启util命名空间
        第一步:
            xmlns:util="http://www.springframework.org/schema/util"
            http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
        第二步
            进行复用
    -->
    <util:properties id="prop">
        <prop key="driver">com.mysql.jdbc.driver</prop>
        <prop key="url">jdbc:mysql://localhost:3306/spring6</prop>
        <prop key="user">root</prop>
        <prop key="password">hsp</prop>
    </util:properties>

    <bean id="mds1" class="jdbc.MyDataSource1">
        <!--进行复用-->
        <property name="properties" ref="prop"/>
    </bean>

    <bean id="mds2" class="jdbc.MyDataSource2">
        <!--进行复用-->
        <property name="properties" ref="prop"/>
    </bean>
</beans>

<!--根据名字进行自动装配-->
    <!--自动装配也是基于set方式实现的-->
    <bean id="orderServiceBean" class="service.OrderService" autowire="byName"/>
    <!--根据名字进行自动装配的时候,被注入的对象的bean的id就不能随便写了,怎么写? set方法的方法名取掉set,剩下单词首字母小写
-->
    <bean id="orderDao" class="dao.OrderDao"/>

    <!--<bean id="orderDaoBean" class="dao.OrderDao"/>-->
    <!--<bean id="orderServiceBean" class="service.OrderService">-->
    <!--<property name="orderDao" ref="orderDaoBean"/>-->
    <!--</bean>-->

<!--根据类型进行自动装配-->
<!--
根据类型进行自动装配的时候, 在有效的配置文件当中,某种类型的实例只能有一个-->
<bean class="dao.UserDao"/>
<bean class="dao.VipDao"/>
<bean id="cs" class="service.CustomerService" autowire="byType"/>

<?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">
<!--
    引入外部的properties文件
        第一步:引入context命名空间
            xmlns:context="http://www.springframework.org/schema/context"

        第二步:使用标签context:property-placeholder的location属性来指定属性配置文件的路径
            默认从类的根路径下加载资源
        第三步: 取值 ${key}
-->
    <context:property-placeholder location="jdbc.properties"/>

    <bean id="ds" class="jdbc.MyDataSource">
        <property name="driver" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <!--有个小瑕疵, username是默认拿当前系统的用户名, 一般会加前缀解决-->
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
</beans>

<!--
    scope属性有两个值
    singleton： 如果不写scope的值，默认就是singleton
    prototype： 这个会取消单例，每次都会调用构造方法重新new对象
    还有其他值（需要引入mvc框架依赖：springmvc）
    request：一次请求种一个bean
    session：一次会话一个bean-->
<bean id="sb" class="bean.SpringBean" scope="prototype"/>

/**
 * 1. Spring默认情况下是如何管理这个Bean的:
 *      默认情况下Bean是单例的。(单例: singLeton)
 *      在Spring上下文初始化的时候实例化。
 *      每一次调用getBean()方法的时候，都返回那个单例的对象
 * 2.当将bean的scope质性设置为prototype:bean是多例的。
 *      spring上下文初始化的时候，并不会初始化这些prototype的bean。
 *      每一次调用getBean()方法的时候，实例化bean对象。
 *      prototype翻泽为: 原型。
 */
构造方法执行了
bean.SpringBean@d62fe5b
构造方法执行了
bean.SpringBean@49964d75
构造方法执行了
bean.SpringBean@528c868

设计模式之:简单工厂模式 Simple Factory Pattern

1。 简单工厂模式是工厂方法模式的一种特殊实现，又被称为: 静态工厂方法模式。

2. 简单工厂模式解决什么问题呢?
    优点:客户端程序不需要关心对象的创建细节，需要哪个对象时，只需要向工厂索要即可，初步实现了责任的分离。
        客户端只负责"消费”，工厂负责“生产”。生产和消费分离。

3。简单工厂模式中的角色:
    * 抽象产品角色
    * 具体产品角色
    * 工厂类角色
4. 简单工厂模式的缺点?
    缺点一:假设现在需要扩展一个新的产品，WeaponFactory工厂类的代码是需要修改的，显然违背了OCP原则。
    缺点二:工厂类的责任比较重大，不能出现任何问题，因为这个工厂类负责所有产品的生产，称为全能类，或者有人把它叫做上帝类。
        这个工厂类一旦出问题，整个系统必然全部瘫痪。 (不要把所有鸡蛋放到一个篮子里面哦。)


工厂方法模式可以解决缺点一

工厂方法模式: Factory Method Pattern

1. 工厂方法模式可以解决简单工厂模式当中的OCP问题。
    怎么解决的?一个工厂对应生产一种产品。
    这样工厂就不是全能类了，不是上帝类了
    另外，也可以符合0CP原则。

2. 工厂方法模式中的角色:
    * 抽象产品角色 Weapon
    * 具体产品角色 Dagger Gun
    * 抽象工厂角色 WeaponFactory
    * 具体工厂角色 DaggerFactory GunFactory

3.工厂方法模式的优点:
    当你扩展一个产品的时候，符合0CP原则，因为只需要添加两个类，一个类是具体产品类，一个类是具体工厂类。都是添加类，没有修改之前的代码，所以符合OCP

4。工厂方法模式的缺点:
    每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，
    在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

//TODO 编写工厂房吗模式的案例

5. 抽象工厂模式可以解决工厂方法模式的缺点