`
yiliner
  • 浏览: 214461 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Spring 学习笔记--强烈推荐

SpringBeanIOC框架配置管理 
阅读更多

<script type="text/javascript"></script> **
* 阅前说明:
* 此文件为笔者在学习Spring时所写的一些笔记<br>
* 希望能抛砖引玉来促进大家以各种方式交流学习心得<br>
* 如有转载,为了尊重笔者的劳动成果，请保留此段说明<br>
* @author    贺小佼 HeXiaojiao<br>
* Email        ld_hxj1@yahoo.com.cn <br>
* QQ     88137099<br>
* Time         2008-04-14 16:43:43 <br>
* Blog    http://blog.csdn.net/hexiaojiao
*/
Day-01
问题提出：
框架的主要优势是什么？
请简要描述Spring?
Spring框架分为哪几个模块，请详述？
Spring有哪些注入方式，请详细描述？

1.在Setter注入方式中,在beans包下的ProductBean中只加入一个带参数的构造

方法会如何？
2.在config.xml中少加一property项会如何？
3.Spring中有哪些集合注入,如何注入？
4.问:如何设置单例模式?有什么作用和特殊效果?
5.问:什么叫混合注入模式,请举例说明?
6.问: Spring中如何进行类型数据的设置
7.问:Spring支不支持数据类型自动转换?构造器复杂情况有哪些？
8.问:如果为嵌套属性(其属性为一个类)时如果配置?(Bean的引用如果配置)
9.问:Bean初始化方案有哪几种,请详述?
10.问:在bean类中(1)初始化接口方案、(2)构造方法与(3)初始化方法方案中各

方法的执行顺序如何？
//=======================================================
问题解决:
//-------------------------------------------------------------------

----------  
框架的主要优势是什么？

请简要描述Spring?

Spring框架分为哪几个模块，请详述？
    答：Spring框架可分为七个模块,分别如下:
     1.核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组

件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC）

模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
      2.Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供

上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际

化、校验和调度功能。
      3.Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的

编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的

任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供

了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性

事务管理集成到应用程序中。
      4.Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该

结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了

错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）

。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
      5.Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM

的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都

遵从 Spring 的通用事务和 DAO 异常层次结构。
      6.Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，

为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta

Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对

象的工作。
      7.Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC

实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术

，其中包括 JSP、Velocity、Tiles、iText 和 POI。
//-------------------------------------------------------------------

----------
Spring有哪些注入方式，请详细描述？
    答: 通过注入方式，使程序解耦合
一。通过构造器(构造方法)注入
构造器注入操作步骤:
   1.引入Spring架包，建包ioc.common 在这包下建立三个包
   ioc.common.beans,ioc.common.config,ioc.common.logic
   2.在beans包下建立UserBean类,代码如下:
  

Java代码 复制代码
  1.      
  2. //UserBean.java   
  3.    package ioc.common.beans;   
  4. public class UserBean {   
  5.         private String userName;   
  6.         private String userPassword;   
  7.   
  8.         public UserBean() {   
  9.         }   
  10.   
  11.         public UserBean(String userName, String userPassword) {   
  12.           this.userName = userName;   
  13.           this.userPassword = userPassword;   
  14.         }   
  15.   
  16.         public String getUserName() {   
  17.           return userName;   
  18.         }   
  19.   
  20.         public void setUserName(String userName) {   
  21.           this.userName = userName;   
  22.         }   
  23.   
  24.         public String getUserPassword() {   
  25.           return userPassword;   
  26.         }   
  27.   
  28.         public void setUserPassword(String userPassword) {   
  29.           this.userPassword = userPassword;   
  30.         }   
  31.   
  32.         @Override  
  33.         public String toString() {   
  34.           return userName + "-" + userPassword;   
  35.         }   
  36. }  
  
//UserBean.java
   package ioc.common.beans;
public class UserBean {
        private String userName;
        private String userPassword;

        public UserBean() {
        }

        public UserBean(String userName, String userPassword) {
          this.userName = userName;
          this.userPassword = userPassword;
        }

        public String getUserName() {
          return userName;
        }

        public void setUserName(String userName) {
          this.userName = userName;
        }

        public String getUserPassword() {
          return userPassword;
        }

        public void setUserPassword(String userPassword) {
          this.userPassword = userPassword;
        }

        @Override
        public String toString() {
          return userName + "-" + userPassword;
        }
}


    3.在config包下建立config.xml文件,内容如下:

Xml代码 复制代码
  1.      
  2.     <?xml version="1.0" encoding="UTF-8"?>  
  3. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"    
  4.   
  5. "http://www.springframework.org/dtd/spring-beans.dtd">  
  6. <beans>  
  7.         <bean id="userBean" class="ioc.common.beans.UserBean">  
  8.           <constructor-arg index="0">  
  9.             <value>Janet </value>  
  10.           </constructor-arg>  
  11.           <constructor-arg index="1">  
  12.             <value>88888888</value>  
  13.           </constructor-arg>  
  14.         </bean>  
  15. </beans>    
  
    <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" 

"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
        <bean id="userBean" class="ioc.common.beans.UserBean">
          <constructor-arg index="0">
            <value>Janet </value>
          </constructor-arg>
          <constructor-arg index="1">
            <value>88888888</value>
          </constructor-arg>
        </bean>
</beans>


    4.在logic包下建立Run.java,内容如下:

Java代码 复制代码
  1.       
  2. package ioc.common.logic;   
  3. import ioc.common.beans.UserBean;   
  4. import org.springframework.context.ApplicationContext;   
  5. import    
  6.   
  7. org.springframework.context.support.FileSystemXmlApplicationContext;   
  8.   
  9. public class Run {   
  10.         public static void main(String[] args) {   
  11.           String fileName = "./src/ioc/common/config/config.xml";   
  12.           ApplicationContext ac = new FileSystemXmlApplicationContext   
  13.   
  14. (fileName);   
  15.           // 取得一个实例   
  16.           UserBean user = (UserBean) ac.getBean("userBean");   
  17.           System.out.println(user);   
  18.         }   
  19. }   
  20. //end of Run.java   
   
package ioc.common.logic;
import ioc.common.beans.UserBean;
import org.springframework.context.ApplicationContext;
import 

org.springframework.context.support.FileSystemXmlApplicationContext;

public class Run {
        public static void main(String[] args) {
          String fileName = "./src/ioc/common/config/config.xml";
          ApplicationContext ac = new FileSystemXmlApplicationContext

(fileName);
          // 取得一个实例
          UserBean user = (UserBean) ac.getBean("userBean");
          System.out.println(user);
        }
}
//end of Run.java


    框架:有固定流程的代码集合,代码中的流程能被反复重用
   
    备注:
1、如果构造器(方法)中没有写任何代码又会如何？
    答:将会输出 null-null,Spring不关心构造器实现何种功能,只去调用执行;
2、如果没有这个构造器会如何？
    答:将会使Spring找不到该构造器而产生异常 

Java代码 复制代码
  1.           
  2.     Exception in thread "main"    
  3.   
  4. org.springframework.beans.factory.BeanCreationException:    
  5.     Error creating bean with name 'userBean' defined in file    
  6.        
  7.   
  8. [/home/tarena/corejava/JSP/SpringPrj/./src/ioc/common/config/config.xm   
  9.   
  10. l]:    
  11.     2 constructor arguments specified but no matching constructor    
  12.   
  13. found in bean 'userBean'    
  14.     (hint: specify index and/or type arguments for simple parameters    
  15.   
  16. to avoid type ambiguities)  
       
    Exception in thread "main" 

org.springframework.beans.factory.BeanCreationException: 
    Error creating bean with name 'userBean' defined in file 
    

[/home/tarena/corejava/JSP/SpringPrj/./src/ioc/common/config/config.xm

l]: 
    2 constructor arguments specified but no matching constructor 

found in bean 'userBean' 
    (hint: specify index and/or type arguments for simple parameters 

to avoid type ambiguities)


3、如果构造器中有多个参数，没有配置其中某个参数会如何？如何处理？
    答:Spring将会产生找不到参数异常,处理方式:建立一个没有该参数的构造

器或写入参数
    Related cause:

org.springframework.beans.factory.UnsatisfiedDependencyException:

Error creating bean with name 'userBean' defined in file

[/home/tarena/corejava/JSP/SpringPrj/./src/ioc/common/config/config.xm

l]: Unsatisfied dependency expressed through constructor argument with

index 1 of type [java.lang.String]: Ambiguous constructor argument

types - did you specify the correct bean references as constructor

arguments?

    Context：包含特定内容的环境
/////////////////////////////////////////////Constructor IOC END   

二。 Set注入
    1.在步骤一的基础上,在beans包下建立ProductBean类,代码如下:
   

Java代码 复制代码
  1.      
  2. //ProductBean.java   
  3. package ioc.common.beans;   
  4. public class ProductBean {   
  5.         private String productName;   
  6.         private String productDiscript;   
  7.   
  8.         public void setProductName(String productName) {   
  9.           this.productName = productName;   
  10.         }   
  11.   
  12.         public void setProductDiscript(String productDiscript) {   
  13.           this.productDiscript = productDiscript;   
  14.         }   
  15.   
  16.         @Override  
  17.         public String toString() {   
  18.           return productName + "-" + productDiscript;   
  19.         }   
  20. }  
  
//ProductBean.java
package ioc.common.beans;
public class ProductBean {
        private String productName;
        private String productDiscript;

        public void setProductName(String productName) {
          this.productName = productName;
        }

        public void setProductDiscript(String productDiscript) {
          this.productDiscript = productDiscript;
        }

        @Override
        public String toString() {
          return productName + "-" + productDiscript;
        }
}


    2.在config.xml中加入如下内容:  

Xml代码 复制代码
  1.   
  2. <bean id="productBean" class="ioc.common.beans.ProductBean">  
  3.       <property name="productName">  
  4.         <value>Motorolla</value>  
  5.       </property>  
  6.       <property name="productDiscript">  
  7.         <value>mebophone producter</value>  
  8.       </property>  
  9.     </bean>   
    
    <bean id="productBean" class="ioc.common.beans.ProductBean">
          <property name="productName">
            <value>Motorolla</value>
          </property>
          <property name="productDiscript">
            <value>mebophone producter</value>
          </property>
        </bean>


     3.在logic包下新建类RunConstructor代码如下
    

Java代码 复制代码
  1.     
  2. //RunSetter.java   
  3. package ioc.common.logic;   
  4.   
  5. import ioc.common.beans.ProductBean;   
  6. import org.springframework.context.ApplicationContext;   
  7. import    
  8.   
  9. org.springframework.context.support.FileSystemXmlApplicationContext;   
  10.   
  11. public class RunSetter {   
  12.         public static void main(String[] args) {   
  13.           String fileName = "./src/ioc/common/config/config.xml";   
  14.           ApplicationContext ac = new FileSystemXmlApplicationContext   
  15.   
  16. (fileName);   
  17.           ProductBean product = (ProductBean) ac.getBean   
  18.   
  19. ("productBean");   
  20.           System.out.println(product);   
  21.         }   
  22. }  
 
//RunSetter.java
package ioc.common.logic;

import ioc.common.beans.ProductBean;
import org.springframework.context.ApplicationContext;
import 

org.springframework.context.support.FileSystemXmlApplicationContext;

public class RunSetter {
        public static void main(String[] args) {
          String fileName = "./src/ioc/common/config/config.xml";
          ApplicationContext ac = new FileSystemXmlApplicationContext

(fileName);
          ProductBean product = (ProductBean) ac.getBean

("productBean");
          System.out.println(product);
        }
}


        问题:
        1.在Setter注入方式中,在beans包下的ProductBean中只加入一个带参

数的构造方法会如何？
        答:将会产生异常Spring异常与JVM异常
        Exception in thread "main"

org.springframework.beans.factory.BeanCreationException:
        Error creating bean with name 'productBean' defined in file
       

[/home/tarena/corejava/JSP/SpringPrj/./src/ioc/common/config/config.xm

l]:
        Instantiation of bean failed; nested exception is
         org.springframework.beans.BeanInstantiationException:
        Could not instantiate bean class

[ioc.common.beans.ProductBean]:
        No default constructor found; nested exception is

java.lang.NoSuchMethodException:
        ioc.common.beans.ProductBean.<init>()
        //JVM异常       
        Caused by: java.lang.NoSuchMethodException:

ioc.common.beans.ProductBean.<init>()
       
        Tips:强烈建议有不带参数的构造器
       
        2.在config.xml中少加一property项会如何？
        答:正常运行，但少加的属性值为null;
       
        3.Spring中有哪些集合注入,如何注入？
        答: Spring中有List,Map,Properties,Set,数组(如 String [] ,使用

同List)等集合注入;
      注入方法:
       在配置文件中<property name="变量名">
       或constructor-arg index="参数序号,从0开始取"加入相应配置参数
       形如:

Xml代码 复制代码
  1. <list>  
  2.   <value>Eric</value>  
  3.   <value>Narci</value>  
  4. </list>  
  5.   
  6. <map>  
  7.   <entry key="HR">  
  8.     <value>人力资源部</value>  
  9.   </entry>  
  10.   <entry key="MIS">  
  11.     <value>信息管理部</value>  
  12.   </entry>  
  13. </map>  
  14.   
  15. <props>  
  16.   <prop key="GG">成俊杰</prop>  
  17.   <prop key="MM">伍欣</prop>  
  18. </props>  
  19.   
  20. <set>  
  21.   <value>CoreJava</value>  
  22.   <value>JDBC</value>  
  23.   <value>AJAX</value>  
  24. </set>   
   
            <list>
              <value>Eric</value>
              <value>Narci</value>
            </list>
            
            <map>
              <entry key="HR">
                <value>人力资源部</value>
              </entry>
              <entry key="MIS">
                <value>信息管理部</value>
              </entry>
            </map>
            
            <props>
              <prop key="GG">成俊杰</prop>
              <prop key="MM">伍欣</prop>
            </props>
            
            <set>
              <value>CoreJava</value>
              <value>JDBC</value>
              <value>AJAX</value>
            </set>


////////////// END Set注入 END
三、 混合注入
         即构造器注入与Set注入方式混合使用
         如问题 5.
        Tips:如果同时在constractor-arg 和property标签中配置同一属性，

则Setter注入方式会覆盖构造器注入
        //-----------------------------------------------------------


  4.问:如何设置单例模式?有什么作用和特殊效果?
  答:在config.xml中设置<bean id="userBean"

class="bean_manager.beans.User" singleton="true">
      其中singleton="true",设定该bean为单例模式;
      作用:调用该类的多个对象时只在第一次实例化
      特殊效果: 调用时第一次创建对象并赋值，对象还在内存中存活，
      在第二次或之后创建对象后不用赋值也能调用前面赋予的属性 值。
//-------------------------------------------------------------------

----------  
5.问:什么叫混合注入模式,请举例说明?
  答:混合注入模式如:
          <constructor-arg index="0">
            <value>Janet </value>
          </constructor-arg>
          <property name="userPassword">
            <null />
          </property>
      这在构造器中设置用户名，而在Set注入中设置密码
//-------------------------------------------------------------------

----------  
   6.问: Spring中如何进行类型数据的设置
   答:在配置文件config.xml中进行设置，在value标签中加入属性type="类型"
        <property name="brithday">
          <value type=”int”>500</value>
        </property>
//-------------------------------------------------------------------

----------  
   7.问:Spring支不支持数据类型自动转换?构造器复杂情况有哪些？
   答:支持;如果构造器中参数个数与设置个数相等则调用String参数的构造器,

否则自动转换类型再进行调用
        如果类型转换失败,则会输出相应出错信息。
//-------------------------------------------------------------------

----------  
  8.问:如果为嵌套属性(其属性为一个类)时如果配置?(Bean的引用如果配置)
   答:配置属性形如:

Xml代码 复制代码
  1.      
  2.         <property name="product">  
  3.           <ref bean="product"/><!--bean名为此配置文件中的另一个(引用类   
  4.   
  5. 的)bean中id属性值-->  
  6.         </property>  
  7.         <property name="brithday">  
  8.           <ref bean="date"/>  
  9.         </property>  
  10.    <bean id="date" class="java.util.Date"></bean>      
  
        <property name="product">
          <ref bean="product"/><!--bean名为此配置文件中的另一个(引用类

的)bean中id属性值-->
        </property>
        <property name="brithday">
          <ref bean="date"/>
        </property>
   <bean id="date" class="java.util.Date"></bean>


//-------------------------------------------------------------------

----------  
   9.问:Bean初始化方案有哪几种,请详述?
   答:有初始化接口方案和初始化方法方案;
       方案一:初始化接口方案如下：

Java代码 复制代码
  1.     
  2. //Bean开发：   
  3.   package init.beans;       
  4.   public class User implements InitializingBean {   
  5.        private String userName;   
  6.        public void afterPropertiesSet () throws Exception {   
  7.          this.userName = "Google";   
  8.          System.out.println("++++++++++++1");   
  9.        }   
  10.        public String getUserName() {   
  11.          return userName;   
  12.        }   
  13.        public void setUserName(String userName) {   
  14.          this.userName = userName;   
  15.        }   
  16.    }  
  
 //Bean开发：
   package init.beans;    
   public class User implements InitializingBean {
        private String userName;
        public void afterPropertiesSet () throws Exception {
          this.userName = "Google";
          System.out.println("++++++++++++1");
        }
        public String getUserName() {
          return userName;
        }
        public void setUserName(String userName) {
          this.userName = userName;
        }
    }


    config.xml的配置没有任何特殊的地方。如下：

Xml代码 复制代码
  1.       
  2. <?xml version="1.0" encoding="UTF-8"?>  
  3. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"    
  4.   
  5. "http://www.springframework.org/dtd/spring-beans.dtd">  
  6. <beans>  
  7.         <bean id="userBean" class="init.beans.UserBean">           
  8.         <property name="userName">  
  9.         <value>Eric</value>  
  10. </property>  
  11.         </bean>  
  12. </beans>   
   
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" 

"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
        <bean id="userBean" class="init.beans.UserBean">        
        <property name="userName">
        <value>Eric</value>
</property>
        </bean>
</beans>


    运行调用代码如下 init.logic.RunLogic.java

Java代码 复制代码
  1.       
  2. package init.logic;   
  3.   
  4. import init.beans.UserBean;   
  5. import org.springframework.context.ApplicationContext;   
  6. import    
  7.   
  8. org.springframework.context.support.FileSystemXmlApplicationContext;   
  9.   
  10. public class RunLogic {   
  11.         public static void main(String[] args) {   
  12.           String fileName = "./src/init/config/config.xml";   
  13.           ApplicationContext ac = new FileSystemXmlApplicationContext   
  14.   
  15. (fileName);   
  16.           String beanName = "userBean";   
  17.           Object obj = ac.getBean(beanName);   
  18.           if (obj != null) {   
  19.             UserBean user = (UserBean) obj;   
  20.             System.out.println(user.getUserName());   
  21.           }   
  22.         }   
  23. }  
   
package init.logic;

import init.beans.UserBean;
import org.springframework.context.ApplicationContext;
import 

org.springframework.context.support.FileSystemXmlApplicationContext;

public class RunLogic {
        public static void main(String[] args) {
          String fileName = "./src/init/config/config.xml";
          ApplicationContext ac = new FileSystemXmlApplicationContext

(fileName);
          String beanName = "userBean";
          Object obj = ac.getBean(beanName);
          if (obj != null) {
            UserBean user = (UserBean) obj;
            System.out.println(user.getUserName());
          }
        }
}


            //输出结果为
              //++++++++++++1
             //Google
       方案二:初始化方法方案步骤如下：
       1.在java Bean中加入初始化方法,形如:
      

Java代码 复制代码
  1.      
  2. //init.beans.UserBean   
  3.        public String initUser() {   
  4.           this.userName = "BaiDu";   
  5.           System.out.println("*******************2");   
  6.           return this.userName;   
  7.         }  
  
//init.beans.UserBean
       public String initUser() {
          this.userName = "BaiDu";
          System.out.println("*******************2");
          return this.userName;
        }


      2.在配置文件./src/init/config/config.xml中写入如下内容:

Xml代码 复制代码
  1.      
  2.       <?xml version="1.0" encoding="UTF-8"?>  
  3. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"    
  4.   
  5. "http://www.springframework.org/dtd/spring-beans.dtd">  
  6. <beans>  
  7.         <bean id="userBean" class="init.beans.UserBean"  
  8.           init-method="initUser">  
  9.           <property name="userName">  
  10.             <value>Eric</value>  
  11.           </property>  
  12.         </bean>  
  13. </beans>   
  
      <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" 

"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
        <bean id="userBean" class="init.beans.UserBean"
          init-method="initUser">
          <property name="userName">
            <value>Eric</value>
          </property>
        </bean>
</beans>


      3.在调用类执行的方法中写入如下代码：

Java代码 复制代码
  1.      
  2.    //init.logic.RunLogic   
  3. package init.logic;   
  4.   
  5. import init.beans.UserBean;   
  6. import org.springframework.context.ApplicationContext;   
  7. import    
  8.   
  9. org.springframework.context.support.FileSystemXmlApplicationContext;   
  10.   
  11. public class RunLogic {   
  12.         public static void main(String[] args) {   
  13.           String fileName = "./src/init/config/config.xml";   
  14.           ApplicationContext ac = new FileSystemXmlApplicationContext   
  15.   
  16. (fileName);   
  17.           String beanName = "userBean";   
  18.           Object obj = ac.getBean(beanName);   
  19.           if (obj != null) {   
  20.             UserBean user = (UserBean) obj;   
  21.             System.out.println(user.getUserName());   
  22.           }   
  23.         }   
  24. }  
  
   //init.logic.RunLogic
package init.logic;

import init.beans.UserBean;
import org.springframework.context.ApplicationContext;
import 

org.springframework.context.support.FileSystemXmlApplicationContext;

public class RunLogic {
        public static void main(S

  


  

    
    
分享到：
      
      
    

  


  

    

      
      |
      Spring源代码解析(一）：IOC容器
    

  

  

        
  

    
  

    
评论

    
    
    
    
  


  

    
发表评论

            
   您还没有登录,请您登录后再发表评论

相关推荐

    springcloud笔记.pdf

    市场正处在探索期，产品升级需求强烈。 - 中小学生市场：呈现多样化发展，题库、家教等领域都有产品活跃。O2O教育方式有望改变传统教学模式。 5. 行业代表网站： - 母婴市场：妈妈网 - 学前教育：宝宝巴士 - ...

    韩顺平Spring笔记

    Spring 强烈推荐使用接口编程，配合DI，可以降低不同层次之间的耦合。例如，创建一个`ChangeLetter`接口，两个实现类`ChangeLetterImpl1`和`ChangeLetterImpl2`，然后在Spring配置文件中声明这两个实现类，并在需要...

    springboot_笔记

    Spring 4.x及之后的版本都强烈推荐使用Java配置，因为它提供了更好的可读性和可维护性。 ## 二、Spring的Java配置方式 ### 1. @Configuration 和 @Bean `@Configuration`注解用于标记一个类为配置类，它相当于XML...

    java8源码-note-project:笔记项目

    java8 源码 学习笔记 项目介绍 个人学习笔记，主要来源于B站上视频的学习，同时会记录平时一些学习和项目中遇到的问题，同步更新在 ...664元/3年（强烈推荐） 【阿里云】云服务器双11狂欢特惠，1核2

    高级java笔试题-JavaCode:java学习旅途中的笔记和代码，笔记都放在README中，方便阅读

    高级java笔试题 目录 这里是java学习过程中的code以及笔记，笔记都放在README.md中方便阅读。 [TOC] 慕课网学习Hibernate的笔记和源码。总共分为三个阶段，基础，...这是学习韩顺平spring教程的实例代码和学习笔记，主

    软件体系结构与设计模式课堂笔记.docx

    这篇课堂笔记涵盖了UML、Spring Boot以及设计模式等多个方面的重要概念。 首先，UML（统一建模语言）是软件开发中用于可视化、规格说明、构建和文档化的标准方法。在UML类图中，我们关注的主要关系有依赖、关联、...

    java8源码-iafoot_blog_notes:iafoot_blog_notes

    java8 源码 HanRX学习笔记 项目介绍 个人学习笔记，主要来源于日常闲暇时间的学习，同时会记录平时一些工作和项目中遇到的问题，同步更新在 ...664元/3年（强烈推荐） 【阿里云】云服务器双11狂欢特惠，1核2G 最

    最新软件开发工程师个人求职应聘简历模板可编辑参考范文.docx

    - **自学能力**：有强烈的自我驱动和学习新技术的动力，这在快速变化的IT行业中至关重要。 总的来说，这份简历充分展示了求职者在软件开发领域的专业技能和实践经验，同时突显了其个人素质和团队合作能力，符合...

    jvmOnJava

    jvm和多线程以及jdk源码相关内容学习相关笔记主要记录在语雀上记录详情请见语雀强烈推荐使用语雀记录文档（这是我用过最好的记笔记的工具）子模块说明 1.jvmx使用java实现一个基本的jvm语雀文档 processon视频推介宋...

    PHYS_511_SP21:面向2021年Spring课程的PHYS 511编码实验室的布局

    以下是有关如何为当时的实验室做好适当准备的指南未来核物理学家如果您打算在这门课之后学习核物理，那么将来很有可能会遇到并使用ROOT。 因此，我强烈建议您在本课程中着重注意本课程。 除非您已经下载了ROOT并与...

Magicbox
Global site tag (gtag.js) - Google Analytics