精华内容
下载资源
问答
  • 容器中只能包含有组件
    千次阅读
    2019-03-26 11:12:47

    在使用Spring框架开发应用的过程中,大家都知道使用Spring开发应用程序,我们应用程序中所有的Bean都是通过Spring的IOC容器来管理。将Bean注入到Spring IOC容器中的方式多种多样,如通过传统的XML方式注入,通过注解的方式注入等。本文我们就通过例子的形式看一看如何通过注解@Configuration和@Bean向容器中注入组件。

    1、首先创建一个Maven项目,加入spring-context和Junit依赖。

    <dependencies>
    <dependency>
    		<groupId>org.springframework</groupId>
    		<artifactId>spring-context</artifactId>
    		<version>5.1.5.RELEASE</version>
    	</dependency>	
    	<dependency>
    		<groupId>junit</groupId>
    		<artifactId>junit</artifactId>
    		<version>4.12</version>
    		<scope>test</scope>
    	</dependency>
    </dependencies>
    

    2、创建一个类Computer(我们需要注入的Bean)

    public class Computer {
    	private String name;
    	private String brand;
    	
    	public Computer() {
    		System.out.println("创建Computer对象... ...");
    	}
    	
    	public Computer(String name, String brand) {
    		super();
    		this.name = name;
    		this.brand = brand;
    	}
    
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getBrand() {
    		return brand;
    	}
    	public void setBrand(String brand) {
    		this.brand = brand;
    	}
    	
    	@Override
    	public String toString() {
    		return "Computer [name="+name+",brand="+ brand +"]";
    	}
    }
    

    3、创建一个配置类BeanConfig

    //配置类==配置文件
    @Configuration //告诉Spring这是一个配置类
    public class BeanConfig {
    	
    	/**
    	 * 向容器中注册一个Bean,类型为返回值类型,id默认为方法名称
    	 * @return
    	 */
    	@Bean
    	public Computer computer() {
    		return new Computer("Latitude","Dell");
    	}
    }
    
    • @Configuration:该注解所标记的类在Spring中就是一个配置类,被该注解所标记的类中包含一个或者多个@Bean注解的方法,这些被@Bean注解的方法将会被Spring容器扫描并用于构建Bean的定义,初始化Spring的IOC容器。

    • @Bean:被注解的方法将会生成一个可以被Spring IOC容器管理的Bean。

    4、获得容器,测试Bean是否被注入

    public class IOCTest1 {
    	@Test
    	public void testIOC(){
    		AnnotationConfigApplicationContext applicatoin = new AnnotationConfigApplicationContext(BeanConfig.class);
    		System.out.println("容器创建完成... ...");
    		String[] names = applicatoin.getBeanDefinitionNames();
    		for (String name : names) {
    			System.out.println(name);
    		}
    		
    		Object computer = applicatoin.getBean("computer");
    		System.out.println(computer);
    		
    		Object computer1 = applicatoin.getBean("computer");
    		System.out.println(computer == computer1);
    	}
    }
    

    这里需要注意:

    通过XML的方式向容器中注入Bean,我们用的是ClassPathXmlApplicationContext容器并传入XML文件的位置,通过注解的形式向容器中注入Bean时,我们用的是AnnotationConfigApplicationContext容器,传入的是Bean的配置类BeanConfig.class。

    执行以上的单元测试,我们将会得到如下结果:

    容器创建完成... ...
    org.springframework.context.annotation.internalConfigurationAnnotationProcessor
    org.springframework.context.annotation.internalAutowiredAnnotationProcessor
    org.springframework.context.annotation.internalCommonAnnotationProcessor
    org.springframework.context.event.internalEventListenerProcessor
    org.springframework.context.event.internalEventListenerFactory
    beanConfig
    computer
    Computer [name=Latitude,brand=Dell]
    true
    

    从运行结果我们可以得知如下的一些结论:

    • 使用@Configuration和@Bean向容器中注入组件,Spring会在容器中注入一些注解处理的Bean。
    • 在默认情况下,Spring在启动容器后会调用构造方法创建对象并放到ioc容器中。
    • 默认情况下,Spring容器都是以单例模式管理Bean,所有对象在Spring容器中都只有一个实例。
    • @Configuration:该注解所标记的类在Spring中就是一个配置类,被该注解所标记的类中包含一个或者多个@Bean注解的方法,这些被@Bean注解的方法将会被Spring容器扫描并用于构建Bean的定义,初始化Spring的IOC容器,该注解告诉Spring这是一个配置类。
    • @Bean:被注解的方法将会生成一个可以被Spring IOC容器管理的Bean,该注解只能用在方法上。

    5、Bean实例的初始化及销毁

    通过注解的方式向IOC容器中注入Bean时,可以通过设置@Bean注解的属性值来指定在创建对象时的初始化方法、销毁方法以及Bean的id等。

    @Bean常用的属性如下:

    • name: 为 bean 起一个名字,如果默认没有写该属性,那么就使用方法的名称为该 bean 的名称;
    • value:为 bean 起一个名字,如果默认没有写该属性,那么就使用方法的名称为该 bean 的名称;
    • initMethod:指定Bean实例的初始化方法;
    • destroyMethod:指定Bean实例的销毁方法,在调用 IoC 容器的 close() 方法时,会执行到该属性指定的方法。不过,只是单实例的 bean 才会调用该方法,如果是多实例的情况下,不会调用该方法;

    修改BeanConfig类的@Bean注解如下:

    @Bean(name="testComputer",initMethod="init",destroyMethod="destroy")
    public Computer computer() {
    	return new Computer("Latitude","Dell");
    }
    

    指定Bean的名称为testComputer,初始化方法为init,销毁方法为destroy。
    在Computer类中加入init、destroy方法。

    public class Computer {
    	//... ...
    	protected void init() {
    		System.out.println("Init方法被调用... ...");
    	}
    	
    	protected void destroy() {
    		System.out.println("Destroy方法被调用... ...");
    	}
    }
    

    修改测试方法如下:

    public class IOCTest1 {
    	@Test
    	public void testIOC(){
    		AnnotationConfigApplicationContext applicatoin = new AnnotationConfigApplicationContext(BeanConfig.class);
    		System.out.println("容器创建完成... ...");
    		String[] names = applicatoin.getBeanDefinitionNames();
    		for (String name : names) {
    			System.out.println(name);
    		}
    		
    		Object computer = applicatoin.getBean("testComputer");
    		System.out.println(computer);
    		
    		Object computer1 = applicatoin.getBean("testComputer");
    		System.out.println(computer == computer1);
    		
    		applicatoin.close();
    		System.out.println("容器关闭了... ...");
    	}
    }
    

    执行测试方法我们可得到如下结果:

    创建Computer对象... ...
    Init方法被调用... ...
    容器创建完成... ...
    org.springframework.context.annotation.internalConfigurationAnnotationProcessor
    org.springframework.context.annotation.internalAutowiredAnnotationProcessor
    org.springframework.context.annotation.internalCommonAnnotationProcessor
    org.springframework.context.event.internalEventListenerProcessor
    org.springframework.context.event.internalEventListenerFactory
    beanConfig
    testComputer
    Computer [name=Latitude,brand=Dell]
    true
    Destroy方法被调用... ...
    容器关闭了... ...
    

    从执行结果我们可以得知如下结论:

    • 使用@Configuration和@Bean向容器中注入组件,Spring会在容器中注入一些注解处理的Bean。
    • 在默认情况下,Spring在启动容器后会马上调用构造方法创建对象并放到ioc容器中。
    • 对象创建完成之后,立马调用对象的初始化方法初始化对象。
    • 默认情况下,Spring容器都是以单例模式管理Bean,所有对象在Spring容器中都只有一个实例。
    • 对象的销毁方法在IOC容器关闭后被调用。

    6、懒加载(@Lazy)

    我们上面所说的Bean实例的创建都是在容器启动之后立马就会创建并执行对应的初始化方法,那么在单例模式下,如果我们希望在容器创建完成之后不用立马就创建实例,而是希望在我们第一次使用Bean时才创建对象并完成对应的初始化动作,然后再将对象放到IOC容器中。

    Spring为我们提供了@Lazy注解,当我们对Bean加上该注解之后,在单例模式下,Spring IOC容器就能够控制在容器创建时就创建对象还是在第一次使用时创建对象。

    • @Lazy:默认为true,即在单例模式下,在Bean上加上该注解,默认第一次使用时创建对象并初始化;当设置为false时,懒加载就失效了。

    修改BeanConfig类如下:

    @Configuration //告诉Spring这是一个配置类
    public class BeanConfig {
    	
    	/**
    	 * 向容器中注册一个Bean,类型为返回值类型,id默认为方法名称
    	 * @return
    	 */
    	@Bean(name="testComputer",initMethod="init",destroyMethod="destroy")
    	@Lazy
    	public Computer computer() {
    		return new Computer("Latitude","Dell");
    	}
    }
    

    我们在Bean上加了@Lazy注解,执行单元测试我们将会得到如下结果:

    容器创建完成... ...
    org.springframework.context.annotation.internalConfigurationAnnotationProcessor
    org.springframework.context.annotation.internalAutowiredAnnotationProcessor
    org.springframework.context.annotation.internalCommonAnnotationProcessor
    org.springframework.context.event.internalEventListenerProcessor
    org.springframework.context.event.internalEventListenerFactory
    beanConfig
    testComputer
    创建Computer对象... ...
    Init方法被调用... ...
    Computer [name=Latitude,brand=Dell]
    true
    Destroy方法被调用... ...
    容器关闭了... ...
    

    从执行结果我们可以得知:

    • 容器创建完成后,并没有马上创建对象并进行初始化,而是在第一次使用时才创建对象并执行相关的初始化操作。

    7、多实例配置(@Scope)

    默认情况下,Spring IOC容器都是以单例的模式来管理Bean,如果我们要创建多个实例怎么办?Spring提供了@Scope注解,我们通过该注解制定Bean的作用域,可以控制在IOC容器中Bean实例是以单例还是其他的方式存在。

    @Scope有如下几个值:

    • prototype:多实例的,ioc容器启动并不会去调用方法创建对象放在容器中,每次获取的时候才会调用方法创建对象;
    • singleton:单实例的(默认值),ioc容器启动会调用方法创建对象放到ioc容器中,以后每次获取就是直接从容器(map.get())中拿;
    • request:同一次请求创建一个实例;
    • session:同一个session创建一个实例;

    修改BeanConfig类如下:

    @Configuration //告诉Spring这是一个配置类
    public class BeanConfig {
    	/**
    	 * 向容器中注册一个Bean,类型为返回值类型,id默认为方法名称
    	 * @return
    	 */
    	@Bean(name="testComputer",initMethod="init",destroyMethod="destroy")
    	@Scope("prototype")
    	public Computer computer() {
    		return new Computer("Latitude","Dell");
    	}
    }
    

    执行单元测试,得到如下结果:

    容器创建完成... ...
    org.springframework.context.annotation.internalConfigurationAnnotationProcessor
    org.springframework.context.annotation.internalAutowiredAnnotationProcessor
    org.springframework.context.annotation.internalCommonAnnotationProcessor
    org.springframework.context.event.internalEventListenerProcessor
    org.springframework.context.event.internalEventListenerFactory
    beanConfig
    testComputer
    创建Computer对象... ...
    Init方法被调用... ...
    Computer [name=Latitude,brand=Dell]
    创建Computer对象... ...
    Init方法被调用... ...
    false
    容器关闭了... ...
    

    根据结果我们可得出如下结论:

    • 当将Bean的作用域(@Scope)设置成prototype之后,ioc容器启动并不会去调用方法创建对象放在容器中,而是每次获取的时候才会调用方法创建对象;
    • 对象创建完成之后立马调用对象的初始化方法初始化对象。
    • 当将Bean的作用域(scope)设置成prototype之后,每次创建的Bean都是不一样的。
    • 当Bean的作用域为非单例模式(singleton)时,对象的销毁方法在IOC容器关闭时不会被调用。

    小结:

    本文我们通过注解的方式演示了如何向Spring IOC容器中注入Bean及如何获取一个Bean实例,同时演示了如何初始化Bean、如何销毁Bean,以及如何设置Bean的作用域及@Scope的值所代表的含义,同时介绍了在单例模式下如何设置在第一次使用Bean时才创建Bean实例,希望对大家有所帮助。

    更多相关内容
  • 组件是Component子类的仔何一个对象正像我们已经看到的,JFrame窗口是一个组件,但不包含其他的子类。在研究特定的组件之前。我们先看一看表示组件的类组之间的一般关系。以Component为基础的一类层次如下图所示,...

    d32e19939d4e11d26c68d428ef8fde5f.png

    6365301500323120816203128.jpg

    组件表示能够显示在屏幕上的各种图形化的实体。组件是Component子类的仔何一个对象正像我们已经看到的,JFrame窗口是一个组件,但不包含其他的子类。在研究特定的组件之前。我们先看一看表示组件的类组之间的一般关系。以Component为基础的一类层次如下图所示,示意图中的箭头指向超类。

    这个示意图显示了Component的一些子类,其中有些对我们很重要。我们已经讨论了通往JFrame类的这条链,其他的分支是新的。所有由Container派生的类都可以包含Component派生的任何类的对象,通常被称作容器(Container).由于Container类是Coinponen类的子类,每个容器对象也是一个Component,所以一个容器又一可以包含另外一些除Window类私其子类以外的容器,即Window类型(或子类)的对象不能包含在其他的容器中。如果你这样做,就会出现一个异常。JCornponent类是窗口中GUI部分使用的所有Swing组件的基础:

    由于这个类是由Container派生来的,所以,全部的Swing组件都是容器。

    正像你所看到的,JApplet类是所有Swing小应用程序的基类。它从Component通过cotainer类派生而来它还从扩展、改进的旧Applet类中继承了方法。你应该注意到JApplet,JFrarme,

    JDialog、Jcomponet类和其子类都在javax.swing包中。Applet类在java.applet中听有其他的类在java.awt.java.applet包很小,只包含一个类加上3个相关的接口,我们并不需要直接使用它。我们常常使用JApplet类定义小应用程序,这比Applet更有意义。320e2eaecc514d233030ca3ba79c9f56.png

    Window和Frame组件

    JFrame对象和Window对象之间的基本区别是,JFrarne对象描述的是应用程序的主窗口,而window对象不是这样。在你创建window对象之前,总需要一个JFrame对象。

    由于Jdialog类直接由Window类派生而来,所以你只能在JFrame对象中创建应用程序中的JDialog对象除了默认的构造函数外,JDialog类的构造函数通常需要一个JFrarme.对象作为自变量传递进来。JFrame对象称为JDialog对象的父类。JFrame对象有一个可调整大小的边框,它可以包含一个内置的菜单栏,由于JFrame对一象是应用程序中的顶层窗口,所以定义的大小和位置与屏幕有关。以JFrame对象为父类的JDialog对象的定位与其父类相关。

    让我们总结一下,通常你将如何使用我们已经讨论过的层次中的关键类。da3e18e55138326a6bc8a661ee91bd53.png

    正像我们所说的,JApplet,

    JFrame和JDialog类都是容器,这是因为它们都以Containe作为基类,所以原则上可以包含任何类的组件。由于它们最终由component派生而来。所以它们自已也都是组件但有些事情并不像组件那么简单,你不能直接地为应用程序或小于程序的GLI将组件添加到程序的JFranme或JApplet对象。让我们看看练习中的的实际工作过程。

    窗口面板

    当你想在窗口中添加GUI组件或绘图时,通过JFrame对象添加的组件或在其上面绘画的内容显示在又JFrame对象管理的窗口面板中。小应用程序也是如此:概括地讲。窗口面板是一个包含描述窗口区域的对象,他们呢来自几种不同的类型。

    我们将使用个大家都称为内容面板的窗口面板。而不使用其他的面板:contcntPane对象之间、其他窗口面板与应用程序本身的关系显示在这里。dc7c3cbd58d665dfa0091295c71bc428.png

    正像你所看到的,在JFrame窗口中标题栏下面的区域对应JRootPane对象,这个对象包含了其他的面板。说明中的layeredPane对象是JlayeredPane类型的。这个面板对应窗口中JRootPane对象占据的整个区域。如果窗口有菜单栏的话,还要进行管理。

    layerPane中菜单栏下面的区域就是contentPane对象,最典型地是在这里添加GUI组件:你还可以在内容面板覆盖的区域显示文字或进行任何绘画。layeredPane对象拥有特别的属性供高级应用程序使用,它允许使用而板中组件组覆盖另一个组件组的分层方式进行竹理。使用这种功能,你可以控制组件与另一个组件的关联显示。在这里,因为层按从后向前的特定顺序显示,所以。在层中前面的组件将位于屏幕该层的后面。

    还有一个辅助的面板没有显示在示意图,这就是glassPane对象。这个对象也对应全部的JRootPane区域。g1assPane象的内容显示在所有其他面板的顶层,因此,这个类可用来很示你想要永远显示在窗口中其他内容之上的组件,例如下拉式菜单、你也可以使用glassPane显示需要频繁更新的图形,如建立动画,当你显示示的内容是动画时,静态的背景可以通过contentPane单独地进行显示。由于每次动画对象需要重画时不需要重新处理背景,所以整个过程效率要高得多。

    JIFrame类定义了几个方法以供你引用们几何面板:fc7d7b26bcfbc413cd9097f0bc8c2e4e.png

    这里讨论的表示面板的所有类本身都是Swing的组件,它们在javax,swing包中定义、JApplet对象与JFrame对象的面板参数相同,所以,向小应用程序添加组件或绘图的操作完全一样由JApplet对象定义的小应用程序,也可以拥有应用程序窗口那样的菜单栏。

    所有的面板以及菜单栏都是组件,因此在我们开始研究如何向窗口中添加菜单栏或其他组件之前,先更详细地看看一般组件的组成。

    考无忧小编推荐:

    更多计算机等级考试真题及答案>>>点击查看

    想知道更多关于计算机等级报考指南、考试时间和考试信息的最新资讯在这里>>>

    本文网址:http://www.k51.com.cn/info/jsjdjks/1802/0126060.html

    展开全文
  • Flutter布局组件

    2021-02-24 15:18:34
    Flutter中的布局容器主要分为两类:只能包含一个子Widget的布局容器和可以包含多个子Widget的容器,下面分别说明其用法。Center组件中的子组件会居中显示。Center组件会尽可能的大,如果你不给它设置任何约束。下面...
  • 当子元素中包含 或 时,全部子元素会垂直上下排列,否则会水平左右排列。 el-header:顶栏容器。 el-aside:侧边栏容器。 el-main:主要区域容器。 el-footer:底栏容器。 以上组件采用了 flex 布局,elemen-ui官方...
  • 展示组件容器组件的区别和应用

    千次阅读 2020-03-12 15:23:54
    在使用React,你是否会出现过一个文件的代码很多,既存在应用数据的读取和处理,又存在数据的显示,而且每个组件还不能复用。 首先我们来看一个容器组件和展示组件一起的例子吧。 class TodoList extends React....

    在使用React中,你是否会出现过一个文件的代码很多,既存在应用数据的读取和处理,又存在数据的显示,而且每个组件还不能复用。

    首先我们来看一个容器组件和展示组件一起的例子吧。

    class TodoList extends React.Component{
        constructor(props){
            super(props);
            this.state ={
                todos:[]
            }
            this.fetchData = this.fetchData.bind(this);
        }
        componentDidMount(){
            this.fetchData();
        }
        fetchData(){
            fetch('/api/todos').then(data =>{
                this.setState({
                    todos:data
                })
            })
        }
        render(){
            const {todos} = this.state;
            return (<div>
                    <ul>
                        {todos.map((item,index)=>{
                            return <li key={item.id}>{item.name}</li>
                        })}
                    </ul>
                </div>)
        }
    }
    

    大家可以看到这个例子是没有办法复用的,因为数据的请求和数据的展示都在一个组件进行,要实现组件的复用,我们就需要将展示组件和容器组件分离出来。

    具体代码如下:

    //展示组件
    class TodoList extends React.Component{
        constructor(props){
            super(props);
        }
        render(){
            const {todos} = this.props;
            return (<div>
                    <ul>
                        {todos.map((item,index)=>{
                            return <li key={item.id}>{item.name}</li>
                        })}
                    </ul>
                </div>)
        }
    
    //容器组件
    class TodoListContainer extends React.Component{
        constructor(props){
            super(props);
            this.state = {
                todos:[]
            }
            this.fetchData = this.fetchData.bind(this);
        }
        componentDidMount(){
            this.fetchData();
        }
        fetchData(){
            fetch('/api/todos').then(data =>{
                this.setState({
                    todos:data
                })
            })
        }
        render(){
            return (<div>
                    <TodoList todos={this.state.todos} />    
                </div>)
        }
    }
    

    当我们把组件分离成容器组件和展示组件这两类时,你会发现他们能够很方便的实现复用。

    展示组件(Presentational Component)

    1. 关注页面的展示效果(外观)
    2. 内部可以包含展示组件和容器组件,通常会包含一些自己的DOM标记和样式(style)
    3. 通常允许通过this.props.children方式来包含其他组件。
    4. 对应用程序的其他部分没有依赖关系,例如Flux操作或store。
    5. 不用关心数据是怎么加载和变动的。
    6. 只能通过props的方式接收数据和进行回调(callback)操作。
    7. 很少拥有自己的状态,即使有也是用于展示UI状态的。
    8. 会被写成函数式组件除非该组件需要自己的状态,生命周期或者做一些性能优化。

    Example:Page,Header,Sidebar,UserInfo,List

    容器组件(Container Component)

    1. 关注应用的是如何工作的
    2. 内部可以包含容器组件和展示组件,但通常没有任何自己的DOM标记,除了一些包装divs,并且从不具有任何样式。
    3. 提供数据和行为给其他的展示组件或容器组件。
    4. 调用Flux操作并将它们作为回调函数提供给展示组件。
    5. 往往是有状态的,因为它们倾向于作为数据源
    6. 通常使用高阶组件生成,例如React Redux的connect(),Relay的createContainer()或Flux Utils的Container.create(),而不是手工编写。

    Example:UserPage, FollowersSidebar, StoryContainer, FollowedUserList

    优点(benifit)

    1. 展示和容器组件更好的分离,有助于更好的理解应用和UI
    2. 重用性高,展示组件可以用于多个不同数据源。
    3. 展示组件就是你的调色板,可以把他们放到单独的页面,在不影响应用程序的情况下,让设计师调整UI。
    4. 这迫使您提取诸如侧边栏,页面,上下文菜单等“布局组件”并使用this.props.children,而不是在多个容器组件中复制相同的标记和布局。

    何时引入容器组件

    我建议你从开始创建组件时只使用展示组件,到最后会意识到你传递了很多props到中间组件,而这些中间组件根本不会用到他们接收到的这些props,仅仅是向下传递。而当这些子组件需要更多的数据时,你需要从新配置这些中间组件。这个时候就需要引入容器组件了。使用容器组件的方式,您可以将数据和行为通过props传递给叶子组件,而不必麻烦一些不相关的中间组件。
    这是一个重构的过程,所以不比在第一次就做对。当你尝试这种模式。在何时应抽取为容器组件你将会有一种直观的感觉。就像您知道何时抽取函数一样

    二分法

    重要的是你需要明白容器组件和展示组件之间不是技术上的区别,而是目的上的区别。

    相比之下,这里有几个相关的(但不同的)技术区别:

    1. 有状态【Stateful】和 无状态【Stateless】:
      容器组件倾向于有状态,展示组件倾向于无状态,这不是硬性规定,因为容器组件和展示组件都可以是有状态的。

    2. 类【Classes】 和 函数【Functions】:
      组件可以被申明成类或函数,函数组件定义简单,但是他缺乏目前仅用于类的一些功能。虽然函数组件有很多限制,但是直到现在还有人使用,是因为函数组件容易理解,建议在不需要自己的state,lifecycle hooks,或性能优化的情况下使用函数组件。这些仅适用于类组件。

    //我们将上边的展示组件改写成函数组件可以如下
    function TodoList(props){
        return (<div>
                  <ul>
                        {props.todos.map((item,index)=>{
                            return <li key={item.id}>{item.name}</li>
                        })}
                    </ul>  
            </div>)
    }
    

    可能很多人不清楚函数组件和类组件的区别,可以去React的官网看一下函数组件和类组件

    1. 纯粹【Pure】 和 不纯粹 【Impure】:
      纯粹:输入什么就输出什么,不会再其中做相应的变动。可以被定义为类或函数,可以是无状态或有状态的,纯组件的另一个重要方面是它们不依赖props或state中的深度变动,所以他们的渲染性能可以通过在shouldComponentUpdate()钩子中进行浅层比较来优化,当前只有类可以定义shouldComponentUpdate()方法。

    不管是展示组件还是容器组件都会有上面的二分特性。在我看来,展示组件往往是没有状态的纯函数,而容器组件往往是有状态的纯类,这仅仅个人观点并非规则。

    当不重要或说很难分清时,不要把分离容器组件和展示组件当做教条,如果你不确定该组件是容器组件还是展示组件是,就暂时不要分离,写成展示组件吧。

    展开全文
  • vue自定义组件中再嵌套其他组件

    千次阅读 2022-03-12 16:28:47
    这样就提出了题目描述的需求:如何实现自定义组件中再嵌套其他组件。俄罗斯套娃。 实现起来十分简单。就是在方框组件(即容器组件)中放置一个插槽(slot)。 1、容器组件(Block.vue) <template> <

    其实就是在容器组件里放一个插槽(slot)。

    VUE的看点是组件。组件应用的典型例子,是一个网站首页。分为若干版块。每个版块都是一个方框框,样式一致,只是版块中间内容不同。对于VUE来说,很自然的想法,就是方框是一个组件,然后里面嵌套个性化内容,或者每个版块索性也做一个组件。这样就提出了题目描述的需求:如何实现自定义组件中再嵌套其他组件。俄罗斯套娃。
    在这里插入图片描述

    实现起来十分简单。就是在方框组件(即容器组件)中放置一个插槽(slot)。

    1、容器组件(Block.vue)

    <template>
      <div>
        <div class="title">
    		{{title}}
        </div>
        <div class="content">
          <slot></slot>
        </div>
      </div>
    </template>
    
    <script>
    export default {
      props: ['title'],
      setup () {
        return {
        }
      }
    }
    </script>
    
    <style scoped>
    .title {
      height: 35px;
    }
    .content {
      padding: 5px;
    }
    </style>
    

    2、子组件(Yacht.vue)

    <template>
      <div>
    	<Button>太空飞船租赁业务备案</Button>
      </div>
    </template>
    

    3、调用

    <Block title="行业动态">
    </Block>
    
    <Block title="备案申请">
      <Yacht />
    </Block>
    

    4、后记
    这种需求本来十分普遍。但在某度上搜索,却极少能找到相应的答案。也许是我搜索条件不对?又或许,找计算机相关资料,某度其实真的需要改进太多。没办法,只能捏着鼻子用下去。

    react上我也遇到过类似问题。解决方案见拙作:
    react小记

    展开全文
  • Android自定义View(二) 自定义容器

    千次阅读 2022-01-23 20:37:25
    目录一、什么是自定义容器1.1 ViewGroup类1.2 ViewGroup的工作原理1.2.1 ViewGroup的onMeasure分析1.2.2 ViewGroup的onLayout分析1.2.3 ViewGroup的onDraw分析二、综合案例2.1 CornerLayout布局2.1.1 分析容器的宽高...
  • 【云原生 | 05】Docker中容器的创建与启停

    千次阅读 多人点赞 2022-06-04 20:19:18
    首先Docker会检查本地是否存在基础镜像,如果本地还没有该镜像的话,那么Docker就会连接官方维护的Docker Hub Registry,查看Docker Hub是否该镜像。Docker一旦找到该镜像,就会下载该镜像并将其保存到本地宿...
  • 使用Swing组件1——使用顶级容器

    千次阅读 2019-03-04 13:54:17
    使用顶级容器 正如我们前面提到的,Swing提供了三个大致有用的顶层容器类:JFrame,JDialog,和JApplet。... 每个GUI组件只能包含一次。如果组件已经在容器中并且您尝试将其添加到另一个容器,则该组件将从第...
  • 比如URL和Controller的绑定,以及URL和方法method的绑定,拦截器的初始化,视图解析器的初始化等web9大组件的初始化 在上篇博文: 【小家Spring】Spring容器(含父子容器)的启动过程源码级别分析(含web.xml启动...
  • java ee容器组件、通信类型简介

    千次阅读 2018-10-11 21:01:32
    1.容器规范:容器组件的运行环境,负责组件的生命周期管理和各组成部分之间的交互协议,定义了各种组件容器类型以及每种容器提供的服务。并管理组件的生成、调用和销毁,简化了企业级软件开发复杂的对象...
  • Vue 组件化开发

    千次阅读 2021-12-07 00:21:40
    功能型组件「UI组件提供的一般都是功能型组件:element/iview/antdv/vant/cube..」 + 一般UI组件库提供的功能组件就够用了 + 偶尔UI组件不存在的,才需要自己封装「难点」 + 我们经常会把功能型组件进行...
  • 【Java Swing开发 组件与布局】

    千次阅读 多人点赞 2021-04-19 22:27:03
    组件及事件处理1 Java Swing概述2 窗口2.1 JFrame常用方法3 常用组件与...如:按钮、菜单、列表、文本框等组件类,同时它还包含窗口、面板等容器类。 javax.swing包提供了功能更为强大的用来设计GUI的类,java.awt和jav
  • WEB组件:的三种关联关系 WEB应用程序如此强大的原因之一就是他们能彼此链接和聚合信息...存在以上关联关系的Web组件可以是JSP或Servlet,对于Struts应用,则还包含Action,这些Web组件都可以访问HttpServletRequest
  • 一、Gitlab CI/CD 简介 ① GitLab GitLab 是一个利用 Ruby on Rails 开发的开源应用程序,实现一个自托管的 Git 项目仓库,可通过 Web 界面... Gitlab CI/CD是一个内置在 GitLab 的工具,用于通过持续方法进行软件
  • view 组件 除了公共属性,view 组件还有以下四个属性scroll-view 滚动视图容器 可以在页面形成一个可以滚动的视图区域,帮助开发者实现页面部分内容的滑动展示。 scroll-view 不能使用 textarea、map、canvas...
  • vue散记:根template只能有一个子元素

    千次阅读 2020-05-29 16:54:44
    vue散记:只能有一个子元素前言template只能有一个子元素1.现象2.原因 前言   之前使用过别人写的vue+element项目,在别人搭建好的框架下修修改改、缝缝补补,感觉还行,整体流程还能走的通,但是不能总是用别人...
  • 在使用React,你是否会出现过一个文件的代码很多,既存在应用数据的读取和处理,又存在数据的显示,而且每个组件还不能复用。 首先我们来看一个容器组件和展示组件一起的例子吧。 class TodoList extends React....
  • 在购物网站上看到轮播图里面是热门商品的信息,在小程序里用 swiper 滑动视图容器组件来实现。  swiper 滑动视图容器组件的属性:  1.indicator-dots:滑动容器面板组件在面板上加一些指示点,指示点就代表当前...
  • 现实容器技术运用案例

    万次阅读 2016-08-30 20:14:44
    很多企业都已经在实际项目或深或浅的使用着容器技术,享受到新技术带来的简洁和高效。作为国内最早研究和使用Docker技术的企业,ThoughtWorks在2013年底就在实际项目中将Docker用于测试环境的资源复用,并在之后的...
  • 基于最新Spring 5.x,详细介绍了Spring MVC的核心组件,包括Handler、HandlerMapping、HandlerAdapter、HandlerExceptionResolver、ViewResolver等组件,最后还大概介绍了Spring MVC的请求执行流程,以及默认的...
  • YARN 的架构是怎样的?YARN 的核心组件有哪些?

    万次阅读 多人点赞 2021-06-16 00:40:24
    每个ResourceRequest可看做一个可序列化Java对象,包含的字段信息如下: , priority, resource-requirement, number-of-containers> JobHistoryServer 作业历史服务,记录在yarn调度的作业历史运行情况情况 , 通过...
  • vue组件间通信六种方式(完整版)

    千次阅读 多人点赞 2019-05-27 09:14:25
    一般来说,组件可以以下几种关系: 如上图所示,A 和 B、B 和 C、B 和 D 都是父子关系,C 和 D 是兄弟关系,A 和 C 是隔代关系(可能隔多代)。 针对不同的使用场景,如何选择行之有效的通信方式?这是我们所要...
  • 但是容器技术经过多年的发展和演变,各种实现方案和早期版本相比已经了巨大的差异,而且仍然在不断演进的过程。各种组件的产生、随之而来的接口规范、基于接口规范实现的新可选组件让相关的名称和概念更加复杂。...
  • 容器技术之发展简史

    千次阅读 2020-10-16 13:36:20
    作者 | 刘奖背景“云原生技术有利于各组织在公有云、私有云和混合云等新型动态环境,构建和运行可弹性扩展的应用。云原生的代表技术包括容器、服务网格、微服务、不可变基础设施和声明式 API。”聊容器技术避不开...
  • Docker容器基础介绍

    千次阅读 2020-12-23 21:58:29
    Docker是PaaS 提供商 dotCloud 开源的一个基于 LXC 的高级容器引擎,源代码托管在 Github 上, 基于go语言并遵从Apache2.0协议开源。Docker是通过内核虚拟化技术(namespace以及cgroups等)来提供容器的资源隔离与安全...
  • Vue组件通信的六种方式

    千次阅读 多人点赞 2022-02-02 11:32:59
    一般来说,组件可以以下几种关系: 如上图所示,A 和 B、B 和 C、B 和 D 都是父子关系,C 和 D 是兄弟关系,A 和 C 是隔代关系(可能隔多代)。 针对不同的使用场景,如何选择行之有效的通信方式?这是我们所...
  • Javaawt基本组件及其使用方法

    万次阅读 2017-10-09 18:44:57
    两种构造方法: public Button() 构造一个标签字符串为空的按钮。 public Button(String label) 构造一个带指定标签的按钮。 当用户鼠标单击按钮时,AWT事件处理系统将向按钮发送一个ActionEvent事件...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 103,304
精华内容 41,321
热门标签
关键字:

容器中只能包含有组件