精华内容
下载资源
问答
  • WEB组件:的三种关联关系 WEB应用程序如此强大的原因之一就是他们能彼此链接和聚合信息...存在以上关联关系的Web组件可以是JSP或Servlet,对于Struts应用,则还包含Action,这些Web组件都可以访问HttpServletRequest

    Web组件:有Jsp,Servlet等 
    Web容器:有tomcat ,jboss, resin, weblogic ,websphere, glassfish。可以理解为Web服务器。


    WEB应用程序如此强大的原因之一就是他们能彼此链接和聚合信息资源。WEB组件之间存在三种关联关系:
    l         请求转发
    l         URL重定向
    l         包含关系
    存在以上关联关系的Web组件可以是JSP或Servlet,对于Struts应用,则还包含Action,这些Web组件都可以访问HttpServletRequest和HttpServletResponse对象,具有处理请求、生成响应结果的功能。
    1.     请求转发。
    请求转发允许把请求转发给同一个应用程序中的其他Web组件。这种技术通常应用于Web应用中的Servlet流程控制器。
    Servlet类使用 javax.servlet.RequestDispatcher.forward()方法来转发。转发目标将处理该请求并生成响应结果,或者将请求转发到另一个组件,最初请求的ServletRequest,ServletResponse对象被传递给转发目标组件,这使得目标组件可以访问整个请求上下文。值得注意的是,只能把请求转发给同一个web应用中的组件。下面是一个例子,当前的servlet组件要把请求转发给一个JSP组件,如hello.jsp,可以在Servlet的service()方法中执行以下代码:
           RequestDispatcher rd = request.getRequestDispatcher(“hello.jsp”);
           Rd.forward(request,response);
    在jsp页面中,可以使用<jsp:forward>标签来转发请求,例如:
    <jsp:forward page=”hello.jsp”/>
    对于请求转发,转发的源组件和目标组件共享request范围内的共享数据。
    2.     请求重定向
    请求重定向类似于请求转发,但也有一些重要的区别:
    l         Web组件可以将请求重定向到任一URL,而不仅仅是同一应用中的URL。
    l         重定向的目标组件与源组件之间不共用同一个HttpServletRequest对象,因此不能共享request范围内的共享数据。
    例如当前应用的Servlet组件把请求转发到URL: http://jakarta.apache.org/struts,可以在Servlet的service()方法中执行以下代码:
           Response.sendRedirect(“http://jakarta.apache.org/struts”);
    HttpServletResponse的sendRedirect()方法向浏览器返回包含重定向的信息,浏览器根据这一信息迅速发出一个新的HTTP请求,请求访问重定向目标组件。
    3.     包含
    Servlet类使用javax.servlet.RequestDispatcher.include()方法包含其他的Web组件。例如当前的Servlet组件包含三个JSP文件:header.jsp/main.jsp/footer.jsp,则可以在servlet的service()方法中执行以下代码:
           RequestDispatcher rd;
           Rd = req.getRequestDispatcher(“/header.jsp”);
           Rd.include(req,res);
           Rd = req.getRequestDispatcher(“/main.jsp”);
           Rd.include(req,res);
           Rd = req.getRequestDispatcher(“/footer.jsp”);
           Rd.include(req,res);
    在JSP文件中,可以通过〈include〉指令来包含其他的web资源,例如:
    <%@ include file=”header.jsp”%>
    <%@ include file=“main.jsp”%>
    <%@ include file=”footer.jsp”%>
    展开全文
  • ScrollView容器组件的用法

    千次阅读 2012-01-12 19:06:35
    ScrollView容器组件居右FrameLayout属性,因此它只能包含一个子组件,该组件通常为一个LinearLayout(线性)布局,这样布局的子组件就可以按照顺序进行排列。 注意区分ScrollView容器组件和ListView容器组件的...

    ScrollView容器组件可以对其中包含的子组件进行竖向的滚动显示(开发者可以选择是否显示滚动条)。ScrollView容器组件居右FrameLayout属性,因此它只能包含一个子组件,该组件通常为一个LinearLayout(线性)布局,这样布局中的子组件就可以按照顺序进行排列。

    注意区分ScrollView容器组件和ListView容器组件的区别:

    相同点:

    这两种容器组件都可以通过竖向滚动的方式显示容器中的内容。

    不同点:

    ListView容器组件是用来显示一组相同类型的数据。

    ScrollView组件可以直接让其子组件进行滚动显示。

    Android文档中特别提醒开发者,不要将一个ListView容器组件作为ScrollView容器组件的子组件,以为这样会破坏系统对ListView容器组件的性能优化。

    下面的XML布局定义演示了如何在XML布局文件中定义一个ScrollView容器组件。

    <?xml version="1.0" encoding="utf-8"?>
    <ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:scrollbars="none">
    
        <LinearLayout
            android:id="@+id/layout"
            android:orientation="vertical"
            android:layout_width="match_parent"
            android:layout_height="wrap_content">
    
            <TextView
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="@string/scroll_view_2_text_1"/>
    
            <Button
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="@string/scroll_view_2_button_1"/>
    
        </LinearLayout>
    </ScrollView>
    


    展开全文
  • 在使用Spring框架开发应用的过程,大家都知道使用Spring开发应用程序,我们应用程序所有的Bean都是通过Spring的IOC容器来...本文我们就通过例子的形式看一看如何通过注解@Configuration和@Bean向容器中注入组件

    在使用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实例,希望对大家有所帮助。

    展开全文
  • 在使用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()方法。

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

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

    展开全文
  • 使用Swing组件1——使用顶级容器

    千次阅读 2019-03-04 13:54:17
    使用顶级容器 正如我们前面提到的,Swing提供了三个大致有用的顶层容器类:JFrame,JDialog,和JApplet。... 每个GUI组件只能包含一次。如果组件已经在容器中并且您尝试将其添加到另一个容器,则该组件将从第...
  • 在使用React,你是否会出现过一个文件的代码很多,既存在应用数据的读取和处理,又存在数据的显示,而且每个组件还不能复用。 首先我们来看一个容器组件和展示组件一起的例子吧。 class TodoList extends React....
  • 1.容器规范:容器组件的运行环境,负责组件的生命周期管理和各组成部分之间的交互协议,定义了各种组件容器类型以及每种容器提供的服务。并管理组件的生成、调用和销毁,简化了企业级软件开发复杂的对象...
  • 在购物网站上看到轮播图里面是热门商品的信息,在小程序里用 swiper 滑动视图容器组件来实现。  swiper 滑动视图容器组件的属性:  1.indicator-dots:滑动容器面板组件在面板上加一些指示点,指示点就代表当前...
  • Flutter布局组件

    2021-02-24 15:18:34
    Flutter中的布局容器主要分为两类:只能包含一个子Widget的布局容器和可以包含多个子Widget的容器,下面分别说明其用法。Center组件中的子组件会居中显示。Center组件会尽可能的大,如果你不给它设置任何约束。下面...
  • Ext JS 6组件容器, 布局

    千次阅读 2016-08-16 17:47:03
    组件Ext JS应用的UI是由一个或者多个widgets组称, 我们称之为Components. 所有的组件都是Ext.Component的子类,允许组件自动管理生命周期, 包括instantiation, rendering, sizing and positioning, 以及...
  • STL组件(components)之容器(container)

    千次阅读 2012-04-04 16:08:26
    STL组件(components)之容器(container) 容器的分类:序列式容器(sequence container)和关联式容器(association container)。其中,序列式容器又称可序(ordered)群集,每个元素的位置取决于插入时机和地点...
  • Flex学习笔记3——组件容器

    千次阅读 2011-08-27 15:22:47
    组件 UIComponent:  组件的基类,所有可视化组件从这继承,而且它是Sprit的子类,具有绘图功能。 常见组件 RadioButtonGroup:控制一组的radioButton。 ApplicationControlBar:实现工具栏 ButtonBar一组...
  • 当子元素中包含 或 时,全部子元素会垂直上下排列,否则会水平左右排列。 el-header:顶栏容器。 el-aside:侧边栏容器。 el-main:主要区域容器。 el-footer:底栏容器。 以上组件采用了 flex 布局,elemen-ui官方...
  • 现实容器技术运用案例

    万次阅读 2016-08-30 20:14:44
    很多企业都已经在实际项目或深或浅的使用着容器技术,享受到新技术带来的简洁和高效。作为国内最早研究和使用Docker技术的企业,ThoughtWorks在2013年底就在实际项目中将Docker用于测试环境的资源复用,并在之后的...
  • 比如URL和Controller的绑定,以及URL和方法method的绑定,拦截器的初始化,视图解析器的初始化等web9大组件的初始化 在上篇博文: 【小家Spring】Spring容器(含父子容器)的启动过程源码级别分析(含web.xml启动...
  • element-uiel-container容器与div布局区分

    万次阅读 热门讨论 2019-04-09 18:03:29
    当子元素中包含 或 时,全部子元素会垂直上下排列,否则会水平左右排列。 el-header:顶栏容器。 el-aside:侧边栏容器。 el-main:主要区域容器。 el-footer:底栏容器。 以上组件采用了 flex 布局,elemen-ui...
  • 2 对容器的关闭只能是粗暴的关闭Bootstrap。 服务器组件 org.apache.catalina.Server接口的实例用来表示Catalina的整个servlet引擎。 我们使用Server就是因为,它用一种优雅的方式来启动/关闭整个系统。 下面是...
  • Library的简称,中文名标准模板库,从根本上说,STL是一些“容器”的集合,这些“容器list、vector、set、map等,STL也是算法和其他一些组件的集合。STL的目的是标准化组件,这样就不用重新开发,可以使用现成的...
  • 2.每当在web容器中有ServletContextListener这个接口被实例化的时候,web容器会通知ServletContextListener被实例的对象去执行其contextInitialized()的方法进行相应的业务处理,而spring框架在设计的过程中...
  • Python GUI之tkinter 常用组件

    万次阅读 多人点赞 2017-12-04 00:13:39
    在实例化的过程,可以通过构造函数给组件设置一些属性,同时还必须给该组件指定一个父容器,意即该组件放置何处。最后,还需要给组件设置一个几何管理器(布局管理器),解决了放哪里的问题,还需要解决怎么放的...
  • 文章目录C++常用的std标准容器顺序容器:有序关联容器:无序关联容器:顺序容器1. vector容器a. vector的定义与初始化b. vecotr常使用的操作c. 小结:2. string容器a. string的初始化b. string中包含的专有的操作...
  • 在Ext JS包含两类布局:组件类布局和容器类布局。由于有些组件不同的组件组合而成的,如字段就由标题和输入框构成,他们之间也是存在布局关系的,而这就需要组件类布局来处理组件内自己特有的布局关系。如果...
  • 1.将页面拆分为粒度更小的组件组件内部除了包含UI实现,还包含数据层和逻辑层; 2.组件提供个性化配置满足两端差异需求,如果无法满足再通过代理抛到上层处理。 页面组件化是一个良好的设计,但它主要适用于解决...
  • React 的高阶组件及其应用场景

    千次阅读 2019-02-25 01:38:32
    React 的高阶组件 属性代理(Props Proxy) 反向继承(Inheritance Inversion) 高阶组件存在的问题 高阶组件的约定 高阶组件的应用场景 装饰者模式?高阶组件?AOP? 总结 什么是高阶组件 在解释什么是高阶...
  • Flex常用组件

    千次阅读 2017-03-11 07:43:21
    Flex常用组件(上)学习内容Ø Flex组件的分类Ø Flex常用组件的使用。Ø 使用组件处理数据和交互Ø ActionScript3.0和JavaScript交互能力目标Ø 掌握使用各种常用组件搭建用户界面Ø 掌握ActionScript3.0和...
  • WebBrowser组件和MSHTML 在Delphi的使用

    千次阅读 2012-10-09 19:09:46
     由于项目需要,近来研究了一下WebBrowser组件和MSHTML 在Delphi的使用,整理了一下这段时间研究的结果,写下来一是方便大家查阅,二也可以加深我自己的记忆.希望能对大家有所帮助… …,同时,如果更好的处理方式...
  • Kubernetes1.5新特性:支持windows容器

    万次阅读 2016-12-19 14:30:21
    在Kubernetes1.5增加了对windows容器的支持,kubelet和kube-proxy已经可以部署在windows操作系统上,但是API Server, Scheduler, Controller Manager等控制功能组件还是需要部署在linux操作系统上。 这是一个α...
  • C++的标准模板库(Standard Template Library,STL)提供了很多的数据容器,以及许多的算法和其他一些组件,整个STL就是由容器(containers)、迭代器(iterators)、空间配置器(allocator)、配接器(adapters)、算法...
  • NOI系列赛 C++容器使用总结

    千次阅读 2015-08-26 10:35:00
    第1章 容器 第1条:慎重选择容器类型。 标准STL序列容器:vector、string、deque和list。 标准STL关联容器:set、multiset、map和multimap。 非标准序列容器slist和rope。slist是一个单向链表,rope本质上是一“重型...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 90,262
精华内容 36,104
关键字:

容器中只能包含有组件