spring控制反转IOC总结

最新推荐文章于 2023-05-23 18:12:54 发布
最新推荐文章于 2023-05-23 18:12:54 发布
阅读量465 收藏
点赞数
分类专栏： JavaWeb 文章标签： spring java ioc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang__ray/article/details/109442909
版权

项目内容：稍微理了下spring的IOC容器发展，在git的版本历史里可以看到IOC思想的不同实现方法。

在这里插入图片描述

一、spring介绍：

  • 概念:

    1. 是一个轻量级的控制反转IOC和切面编码AOP的容器框架。
    2. 它是为了解决企业应用开发的复杂性而创建的。
    3. 在spring的发展过程中，离它的初心越来越远。

  • 雏形：

    1. 最老的interface21框架是雏形。

  • Spring作者：

    1. Rod Johnson

  • 理念：

    1. IOC使开发更简单，整合一些技术。如SSH和SSM。

  • 特点：

    1. 很强的向后兼容性。

    2. 大杂烩，在SSH和和SSM发展中不断地往spring中加入别的东西。

  • Spring优点：

    1. 开源
    2. 轻量级（体积很小），非入侵式的
    3. 核心：控制反转IOC，面向切面AOP
    4. 由于有ＡＯＰ所以支持事务的支持，对框架的整合支持。

  • Spring弊端：

    1. 发展太久，违背了当初的理念，也就是配置太多了，多到记不下来的程度。

二、控制反转（IOC ）的思想:

(一)理解控制与反转：

Control：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的。而使用spring后，对象是由spring的bean容器来创建。

Inversion：程序本身不创建对象， 而变成被动的接收对象。

inversion of control：把创建对象的过程交给spring管理。

(二)假设编写的类有：

  1. UserDao实现类

    public class UserDaoByOracle {
    public void findUserInfoInDB() {
        System.out.println("通过Oracle获取User信息");
    }
}

    public class UserDaoBySqlserver {
    public void findUserInfoInDB() {
        System.out.println("在SQL server数据库中获取了User的信息");
    }
}

  2. UserServicel业务类

    public class UserServer {

    public void getUserInfo(){
        
        //UserDaoBySqlserver u = new UserDaoBySqlserver();
        //修改为：
        UserDaoByOracle u = new UserDaoByOracle();
        u.findUserInfoInDB();
    }
}

(三)IOC的思想产生原因：

1. 没有IOC的时候 ：

​ 我们是在ServiceImp层里面去new，去主动选择对应的DaoImp类，控制权在程序员，每次更新DaoImp的类型，比如从UserDaoByOracle更新UserDaoBySqlserver的类；那么ServiceImp都要去改变new出来的DapImp类，即从new UserDaoByOracle换成new UserDaoBySqlserver的类。

​ 虽然现在看来改动一句UserDaoByOracle u = new UserDaoByOracle()很容易，但是项目很大的时候，各个地方都有可能需要去改动，非常麻烦，难以维护。

2. 加入IOC思想（最简单的，在ServiceImp写setXXX方法）：

public class UserServiceImp implements UserService {
    UserDao userDao;
//  UserDao userDao = new UserDaoByOracleImp();
//  UserDao userDao = new UserDaoBySqlserverImp();

    //利用set方式进行动态注入依赖类
    public void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }

    public void getUserServer() {
        userDao.getUser();
    }
}

增加一个 setUserDao方法后，ServiceImp层的代码里面里面不再去new，而是从调用setUserDao的地方被动地接受传入的DaoImp类型。主动权在调用ServieImp的setUserDao方法这里。这样每次改变DaoImp的类型，切换mysql还是Oracle，就不用改动ServiceImp的代码了，直接在调用ServieImp的setUserDao方法这里，给ServiceImp传入不同的DaoImp类型就好了。

​ 以上的改动所表达的意思就是IOC的原型。

三、bean的引入：

(一)bean的概念：

定义：bean 定义包含称为配置元数据的信息，不理解但知道怎么用就好。

(二)实例化bean的手段：

1.用无参数的构造方法注册

注：也叫 构造器实例化（这个最常用，后续默认此方法）

	1.在配置文件中配置如下
		<?xml version="1.0" encoding="UTF-8"?>
		<beans xmlns="http://www.springframework.org/schema/beans"
		    
			<!-- 关键部分 -->
		    <bean id="bean1" class="Educoder.Bean1"></bean>
		
		</beans>
	这样我们就创建了一个id为user的Bean，之后就可以在项目中任意位置通过容器的getBean方法进行访问User类。
	
	<bean class="org.sang.User" id="user"/>
	
	2.定义要获取的bean1类
	public class Bean1 {
		public void print(){
			System.out.println("Bean1......");
		}
	}
	
	3.获取bean1
	public void textUser(){
		 //1.获取spring文件
		 ApplicationContext context = new ClassPathXmlApplicationContext("Bean.xml");
		 //2.由配置文件返回对象
		 Bean1 b = (Bean1)context.getBean("bean1");
		 System.out.println(b);
		 b.print();
}
2.使用静态工厂创建
	1.配置
	<bean id="bean2"   class="com.spring.demo.Bean2Factory"   factory-method="getBean2"></bean>
	
	2.定义要获取的bean2类
	public class Bean2 {
		public void print(){
			System.out.println("Bean2......");
		}
	}
	
	3.定义静态工厂类
	public class Bean2Factory {
		public   static Bean2 getBean2(){
			return new Bean2();
		}
	}
	
	4.取bean2
	public void textUser(){
		//1.获取spring文件
		ApplicationContext context = new ClassPathXmlApplicationContext("Bean.xml");
		 //2.由配置文件返回对象
		 Bean3 b = (Bean2)context.getBean("bean2");
		 System.out.println(b);
		 b.print();
	}
	
//还是bean节点， class 不再直接指向待实例化的bean2，而是指向静态工厂类-Bean2Factory，只是多了一个factory-method属性，该属性指明该类中的静态工厂方法名为"getBean2"，这样Spring框架就知道调用哪个方法来获取bean2的实例了
3.使用实例工厂创建

	1.配置
	<bean id="bean3  factory" class="com.spring.demo.Bean3Factory"></bean>
	<bean id="bean3" factory-bean="bean3factory" factory-method="getBean3"></bean>
	
	
	2.定义要获取的bean3类
	public class Bean3 {
		public void print(){
			System.out.println("Bean3......");
		}
	}
	
	3.定义非静态工厂类
	public class Bean3Factory {
		public 　　 Bean3 getBean3(){
			return new Bean3();
		}
	}
	
	4.取bean3
	public void textUser(){
	/1.获取spring文件
			 ApplicationContext context = new ClassPathXmlApplicationContext("Bean.xml");
			 //2.由配置文件返回对象
			 Bean3 b = (Bean3)context.getBean("bean3");
			 System.out.println(b);
			 b.print();
	}
	
//静态工厂类与非静态工厂类的区别是，前者不需要创建对象，直接可以调用静态方法创建bean；后者则要先创建对象，然后再通过对象调用其方法创建bean

(三)bean的生命周期：

原型模式：

  1. bean类的创建在调用.getBean（id）的时候，即创建了。

单例模式

  1. 当IOC容器被加载时，所有的Bean都被实例化了。

(四)Bean对象的作用域：

<bean id="bean2"   class="com.spring.demo.Bean2Factory" scope = "singleton"></bean>
<bean id="bean2"   class="com.spring.demo.Bean2Factory" scope = "prototype"></bean>

scope属性值:

scope属性可取值描述
singleton单例模式，每次从容器中取出的Bean对象都是同一个。spring默认选择。
prototype原型模式，每次从容器中取出的Bean对象，都会重新new一个。
request…
session…
application…

四、显式装配：

概念解释
依赖bean对象的创建依赖于容器
注入bean对象中的所有属性，由容器来注入

(一)IOC的实现-通过set方法完成依赖注入

xml注册bean，property标签完成依赖注入。底层还是调用的Set方法。

<?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="userDaoByOracleImp" class="org.experience.share.dao.UserDaoByOracleImp"></bean>
    <bean id="userDaoBySqlserverImp" class="org.experience.share.dao.UserDaoBySqlserverImp"></bean>

    <bean id="userServe" class="org.experience.share.serve.UserServe">
        <property name="userDao" ref="userDaoByOracleImp"/>
        //<property name="brand" value=" 红旗 CA72"/>
    </bean>

</beans>

bean标签的属性

属性作用
id唯一识别该bean的名称。比如使用构造器实例化该bean时，构造器通过该id的值去容器中找这个bean。使用注解@bean（[name= ]），自动生成bean的时候，该bean的id默认为该类的名称首字母小写。
class该bean对应的类的实际绝对路径，无需带上.java后缀。

property标签的属性

属性作用
name该bean对象中的属性的名称。
ref该bean中的某个属性是一个类，则装配的时候，需要选择一个已经成为bean的类进行装入。
value该bean中的某个属性是一个基本类型，则装配的时候，指定相应的值。

通过setXXX方法完成依赖注入

	private UserDao userDao;

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


    <bean id="userDaoByOracleImp" class="org.experience.share.dao.UserDaoByOracleImp"></bean>
    <bean id="userDaoBySqlserverImp" class="org.experience.share.dao.UserDaoBySqlserverImp"></bean>

    <bean id="userServe" class="org.experience.share.serve.UserServe">
<!--        <property name="userDao" ref="userDaoBySqlserverImp"/>-->
        <property name="userDao" ref="userDaoByOracleImp"/>
    </bean>

(二)IOC的实现-通过构造器完成依赖注入

构造器完成依赖注入

public class UserServiceImp(){
    
    DaoBySqlserver daoBySqlserver;
    
    public UserServiceImp(){
        super();
    }
    
    public UserServiceImp(DaoBySqlserver daoBySqlserver){
        this.daoBySqlserver = daoBysqlserver;
    }
    
    public void getUserInfo(){
        print("...")
    }
}

<bean id="userServiceImp" class="org.wr.software.experience.service.imp.UserServiceImp">
		<constructor-arg index="0" value = "有参构造的第一个参数值" />
    	//<constructor-arg type="java.lang.String" value = "有参构造的参数值只有一个参数" />
    	//<constructor-arg name="实参名称" value = "有参构造的参数值" />
</bean>

注：constructor-arg标签-有参构造时使用

通过下标给构造参数赋值；

- index="0"：表示给第1一个参数赋值
- value="": 具体值

通过类型给构造参数赋值；

- type="java.lang.String" 
- value = "有参构造的参数值只有一个参数"

通过参数名给构造参数赋值；

- name="实参名称"
- value = "有参构造的参数值"

五、自动装配：

注：自动装配是spring满足bean依赖的一种方式。

(一) XML注册Bean,配置autowired属性完成自动装配

autowire属性的值

值作用
ByName给这个bean对象里面的类属性赋值时，会自动在容器上下文中查找，和自己对象set方法后面的值(首字母小写)，相同的Bean的id，成功找到就赋该Bean。
ByType给这个bean对象里面的类属性赋值时，会自动在容器上下文中查找，和自己对象属性类型相同的Bean的id，成功找到就赋值该Bean。
public class UserDaoByOracleImp implements UserDao {
    public void findUserInfoInDB() {
        System.out.println("通过Oracle获取User信息");
    }
}

public class UserServe {
    UserDao userDao ;

    public void getUserInfo(){

        userDao.findUserInfoInDB();
    }

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

  • byName

       <bean id="userDao" class="org.wr.software.experience.dao.imp.UserDaoBySqlserverImp"></bean>
   <bean id="userServiceImp" class="org.wr.software.experience.service.imp.UserServiceImp" autowire="byName"></bean>
   //会去匹配和id叫userDao的Bean， 即此处的userDao。

  • ByType

    <-- <bean id="userDao1" class="org.wr.software.experience.dao.imp.UserDaoByOracleImp"></bean>   -->
    <bean id="userDao2" class="org.wr.software.experience.dao.imp.UserDaoBySqlserverImp"></bean>
    <bean id="userServiceImp" class="org.wr.software.experience.service.imp.UserServiceImp" autowire="byType"></bean>
    //会去匹配和UserDao类型一致的Bean，这里配置的userDao2是UserDao的子类，故会被装配上。
    //若能匹配Bean超过一个，则报错，上面放开就会报错。

(二) XML注册Bean,注解完成自动装配

注：spring2.5后即开始支持注解实现。

注：若是直接在属性上加注解，则是通过底层的反射机制实现的。

注：如果是加在setXXX方法上，则是通过setXXX方法实现的。

对比@Autowired@Resource
注解来源Spring注解JDK注解(JSR-250标准注解，属于J2EE)
装配方式默认通过byType的方式来查找容器中的Bean；
若需要使用byName的方式来查找容器中的Bean；则需要配合使用@Qualifier(value = “beanName”)。		默认通过byName的方式来查找容器中的Bean，没找到才会按照byType的方式来查找。
@Resource([ name = “” ] / [ type = “” ])
属性@Autowired(required=False)表示依赖的类不允许是null类型。@Resource([ name = “” ] / [ type = “” ])
注意也可以写在setXXX方法上，前提是该类已经在Bean容器中。

  • @Autowired

    默认byType，如果用要用byName则必须要求这个对象存在。

  • @Resource

    默认byName，找不到再去byType，还没找到就报错。

  1. @Autowired的作用要生效：有一个地方要注意

①需要修改xml的命名空间；（加content)

②需要在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">

    <context:annotation-config/>

    <bean id="userDao2" class="org.wr.software.experience.dao.imp.UserDaoBySqlserverImp"></bean>
    <bean id="userServiceImp" class="org.wr.software.experience.service.imp.UserServiceImp" />

</beans>

(三) 注解注册Bean,注解完成自动装配

  1. 能够注册Bean的注解：

    @component = @Service 、@Controller 、@Repository (@Scope… 、)

    @Autowired = @Resource

    //该类被spring管理了，即成为了Bean。
//相当于<bean id = "user" class="org.www.xxx.xxx"/>,id默认为首字母小写版本
@component
//@Scope（"prototype"）
public class User{
    @Value("WR")
    public String name;
    //相当于<property name = "name" value = "WR"/>
}

  2. @component等注解的作用要生效：有两个地方要注意

    ①需要修改xml的命名空间；（加content)

    ②需要在xml文件中间加入 <context:annotation-config />，表示支持注解完成依赖注入。

    ③需要在xml文件中加入**<context:component-scan base-package=“org.wr.software.experience.dao”/>**，表示该目录下的注解生效。

    <?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/>
    <context:component-scan base-package="org.wr.software.experience.dao"/>
    <context:component-scan base-package="org.wr.software.experience.service"/>

</beans>

六、自动装配（脱离xml）

实际上底层还是或多或少使用了第五点第（三）项里面的注解，只不过不需要再去配置XML文件了

  1. springboot中能够完成注册Bean的注解

    @Configuration 、@Bean

    //Configuration注解表示下面的这个类是一个配置类，即Bean.xml文件。
//该注解的底层实现其实也加了@component
@Configuration
public class User{
	
    //等价于<bean id="makeUserBean" class="org.xxx.xxx.xx" />
    //id为方法名，class为返回的类的位置。
    @Bean
    public  User makeUserBean(){
		return new User();
    }
}
@component  = @Service 、@Controller 、@Repository (@Scope... 、)

@Autowired = @Resource

  3. 如果完全使用了配置类的方式去注册bean，那么只能通过AnnotationConfig上下文来获取容器,参数为@Configuration配置类对象。

    public class MyTest{
    public static void main(String [] args){
        AnnotationConfigApplicationContext acac = new AnnotationConfigApplictionContext("User.class);
        User u = (User) context.getBean（"makeUserBean"）;
    }
}

  4. 多认识几个注解

    @import（其他配置类）

    如果有多个@Configuration配置类对象，那么可以在任意一个@Configuation上写import（其他配置类），使之成为一个类。

    @ComponentScan（其他包的路径）

    如果你的其他包都在使用了@SpringBootApplication注解的main app所在的包及其下级包，则你什么都不用做，SpringBoot会自动帮你把其他包都扫描了

    如果你有一些bean所在的包，不在main app的包及其下级包，那么你需要手动加上@ComponentScan注解并指定那个bean所在的包

七、注意点

  1. SpringBoot项目的Bean装配默认规则是根据Application类所在的包位置从上往下扫描！
    “Application类”是指SpringBoot项目入口类。这个类的位置很关键：

    如果Application类所在的包为：io.github.gefangshuai.app，则只会扫描io.github.gefangshuai.app包及其所有子包，如果service或dao所在包不在io.github.gefangshuai.app及其子包下，则不会被扫描

  2. @Autowired是Spring 提供的,默认按照byType 注入，也就是bean的类型的来传入。如果需要指定名字，那么需要使@Qualifier("这是bean的id名字")

  3. @Resource装配顺序：

    ①如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常。

    ②如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常。

    ③如果指定了type，则从上下文中找到类似匹配的唯一bean进行装配，找不到或是找到多个，都会抛出异常。

    ④如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配。

    @Resource的作用相当于@Autowired，只不过@Autowired按照byType自动注入。

个类的位置很关键：

如果Application类所在的包为：io.github.gefangshuai.app，则只会扫描io.github.gefangshuai.app包及其所有子包，如果service或dao所在包不在io.github.gefangshuai.app及其子包下，则不会被扫描

  1. @Autowired是Spring 提供的,默认按照byType 注入，也就是bean的类型的来传入。如果需要指定名字，那么需要使@Qualifier("这是bean的id名字")

  2. @Resource装配顺序：

    ①如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常。

    ②如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常。

    ③如果指定了type，则从上下文中找到类似匹配的唯一bean进行装配，找不到或是找到多个，都会抛出异常。

    ④如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配。

    @Resource的作用相当于@Autowired，只不过@Autowired按照byType自动注入。

wang__Ray
关注
专栏目录
Spring控制反转IOC与依赖注入DI和AOP切面编程
m0_37601917的博客
12-25 516
IOC控制反转         IoC叫控制反转，英文Inversion of Control，控制反转就是把 由程序代码直接操作的对象第调用权交给容器处理，通过容器实现对象组件的装配和管理。说白了就是 对组件对象控制权的转移，从程序转移到外部容器，由容器创建对象并管理对象间依赖关系。         控制反转的技术大大促进了代码间的松耦合。一个对象依赖的其他对象会通过被动的方式传递进来，而不...
Spring——Spring核心（IoC）控制反转详细说明
Java_zhujia的博客
11-15 526
控制反转IoC(Inversion of Control） 是一个概念，是一种思想。指将传统上由程序代码直接操控的对象调用权交给容器，通过容器来实现对象的装配和管理。控制反转就是对对象控制权的转移，从程序代码本身反转到了外部容器。通过容器实现对象的创建，属性赋值， 依赖的管理。IoC 是一个概念，是一种思想，其实现方式多种多样。当前比较流行的实现方式是依赖注入。应用广泛。
Spring IoC控制反转总结
天天开心
09-28 142
Spring IoC控制反转总结 [code] IoC（Inversion of Control）经常称为控制反转或是依赖注入（Dependence Injection）。通俗的讲就是若需要在具体的应用程序中需要创建一个对象的话，我们不用自己去通new方法生成需要的对象，而是通过spring程序包提供的bean工厂为我们生产这样的一个对象。 在IoC模式下，应用程序不负责...
Spring详解之（控制反转IOC，依赖注入DI）
文帝的博客
02-24 407
概述 1.什么是Spring Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。 它是为了解决企业应用开发的复杂性而创建的。 Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。...
nginx对于XXX.com和XXX.com/index给映射到www.xxx.com的方式
fhb19870610的专栏
05-15 41万+
location / {             root    C:/website;             index   index.html index.htm index.php;             include C:/website/.htaccess; if ($host !~ "www.xincanzs.com") { rewrite
xxx.com和www.xxx.com的区别
weixin_42613703的博客
12-22 79万+
XXX.com 是主域名！ WWW.xxx.com 一般是域名的主页！ 在很多情况下，会配置成一样！！！ 也有可能，主域名不配置到具体的IP，可能无法解析。。 C:\Windows\system32&gt;nslookup baidu.com 服务器: UnKnown Address: 61.128.114.133 非权威应答: 名称: baidu.com Addresses: 22...
wwwxxx域名选择(www.xxx.com或者.cn)
计算机毕业论文源码，学生个人网页制作html源码。贴近用户做网络推广和互联网优化。
12-26 72万+
域名就是网站的网址，就跟家庭住址一样，那么域名就是我们网站的地址，我们使用方便记忆的域名（字母/数字+.COM等域名后缀:www.xxx.com）。 按所属机构分常见后缀形式： COM：商业性的机构/公司/个人，因为COM这个后缀公信度高，所以用得比较多 ORG ：非盈利的组织、团体 GOV：政府部门 NET：从事Internet相关的的机构或公司 EDU：教育机构 .互联网通用顶级域之一，主要供教育机构，如大学等院校使用，实际使用的教育机构大部分位于美国。 注意：还有很多，但是不常见，就先不
Spring框架控制反转IOC和依赖注入DI详解
01-20
本文介绍了Spring框架中的控制反转IOC和依赖注入DI，欢迎阅读，共同学习，一起进步。 Spring框架基础参考：深入学习Spring基础 文章目录一.入门程序和IOC简介二.IOC-控制反转三.DI-依赖注入四. IOC和DI五.Spring...
Spring.Net控制反转IoC入门使用
08-30
本文主要关注的是Spring.NET的核心特性——控制反转（Inversion of Control，简称IoC）。 控制反转是一种设计模式，它将对象的创建和依赖关系的管理从应用代码中解耦出来。通过IoC，对象不再负责创建和管理其依赖项...
Spring核心之控制反转(IOC)
一名很普通的互联网打工人
04-30 414
如何理解IoC Spring Bean是什么 IoC Container管理的是Spring Bean， 那么Spring Bean是什么呢？ 本人整理各种Java核心知识点与多家公司面试知识点整理 免费分享给大家，我认为是非常有用的，想要资料的话请点 白嫖这份礼物←戳我 Spring里面的bean就类似是定义的一个组件，而这个组件的作用就是实现某个功能的，这里所定义的bean就相当于给了你一个更为简便的方法来调用这个组件去实现你要完成的功能。 IoC是什么 Ioc—Inversion ..
ThinkPHP下访问www.xxx.com访问成功www.xxx.com/后加上index、admin等报错
m0_37360025的博客
05-22 9万+
原因主要是Apache不支持.htaccess 1.httpd.conf，如果是多域名的要加上httpd-vhosts.conf Options FollowSymLinks AllowOverride None 改为： Options FollowSymLinks AllowOverride All 2. httpd.conf中开启LoadModule rewrite_module modules/mod_rewrite.so ...
如何在本地设置www.xxx.com,使其允许访问
weixin_30429201的博客
04-21 18万+
1. 打开C:\Windows\System32\Drivers\etc 的hosts 文件 2. 在host文件写一行话： 192.168.1.40 www.xxx.com 3. 这样就可以打开 www.xxx.com 4. 若有开防火墙，须对端口开例外 转载于:https://www.cnblogs.com/kittyguo/p/5417744.html...
无法解决此远程名称：“www.xxxxxx.com“的解决方法
热门推荐
Ling_smile的博客
01-08 85万+
分析原因：从防火墙屏蔽端口到支付宝签约id是否过期，最后才找出原因，原来我的服务器DNS解析错误，无法访问到调用的远程服务器。原因是：服务器不能上外网。     解决办法如下：         在服务器上执行：开始|运行|cmd  ping www.***com  //注:ping 后面的地址是你调用的远程服务器的域名。         如果可以ping通，说明DNS解析正确。      ...
thinkphp 项目，本地项目用www.XXX(自己填的名称).com访问方式
weixin_42231483的博客
08-03 8万+
本地项目用www.XXX(自己填的名称).com访问方式 第一步 ： 先进入 C:\Windows\System32\drivers\etc\hosts 打开hosts文件，在最后一行添加 127.0.0.1 localhost www.xxx1.com www.xxx2.com www.xxx3.com … 等等 www.xxx1.com 就是自...
ios局域网ota无法连接www.xxx.com的问题解决记录。
qq_35916684的博客
07-31 5万+
提示无法连接局域网内ota服务 1、业务中要使用内网分发ipa包，但总是显示无法连接www.xxx.com，但吧manifest.plist发送至服务器上nginx来处理却没有问题且可以正常下载，而且发送到服务器的manifest.plist文件内的下载链接还是本地的网址。 分析问题。 本地和线上没有区别，只是域名不同。把两边都下载一遍发现，本地的是直接在浏览器内打开。而线上却是自动下载了。 那么...
未匹配到本域名(www.xxx.com)有效授权码，请到PbootCMS官网获取
最新发布
糖果云专栏
05-23 14万+
PbootCMS默认授权提示语句为：未匹配到本域名(www.xxx.com)有效授权码，请到PbootCMS官网获取，并填写到网站后台"全局配置>>配置参数"中。
【老王读Spring IoC-5】Spring IoC 小结——控制反转、依赖注入
老王的专栏
08-31 415
Spring IoC 小结前言正文控制反转依赖注入AbstractApplicationContext#refresh()小结 系列博文： 【IoC-0】SpringIoC引入 【IoC-1】IoC之控制反转引入 【IoC-2】IoC之BeanDefinition扫描注册 【IoC-3】Spring bean 的创建过程 【IoC-4】IoC之依赖注入原理 相关阅读： @Resource与@Autowired的区别 bean name 的生成规则 前言 前面从源码的角度逐步分析了 Spring IoC 的实
spring IOC笔记，@Autowired 与@Resource
jiachanghui007的博客
02-18 114
spring IOC笔记，@Autowired 与@Resource 控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup） spring编程的风格 schemal-based-------xml annotation-based-----annotation java-based
理解Spring中的IoC控制反转与依赖注入
"Spring中使用Ioc控制反转" 在Spring框架中，IoC（Inversion of Control）控制反转是一种设计原则，它改变了传统程序中的控制流程，将对象的创建和管理权交给了外部容器，即Spring IoC容器。这一概念的核心在于解耦...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值