精华内容
下载资源
问答
  • Window parent 属性

    千次阅读 2016-03-17 21:07:09
    parent属性返回当前窗口的父窗口。 语法 window.parent 浏览器支持 所有主要浏览器都支持 parent 属性 实例 实例 当打开新窗口时,在父窗口弹出警告: function ...

    Window parent 属性

    Window 对象参考手册 Window 对象

    定义和用法

    parent属性返回当前窗口的父窗口。

    语法

    window.parent


    浏览器支持

    Internet ExplorerFirefoxOperaGoogle ChromeSafari

    所有主要浏览器都支持 parent 属性


    实例

    实例

    当打开新窗口时,在父窗口弹出警告:

    <html>
    <head>
    <script>
    function openWin()
    {
    window.open('','','width=200,height=100');
    alert(window.parent.location);
    }
    </script>
    </head>
    <body>

    <input type="button" value="Open window" οnclick="openWin()">

    </body>
    </html>

    尝试一下 »


    Window 对象参考手册 Window 对象
    展开全文
  • 一、bean标签的parent属性 Spring Framework Reference Documentation 6.7. Bean definition inheritance 该节详细介绍了 bean的继承关系(bean标签的parent属性),下面简单翻译一下:A bean definition can ...

    一、bean标签的parent属性

    Spring Framework Reference Documentation 6.7. Bean definition inheritance

    注:本文中bean和definition意思等同

    该节详细介绍了 bean的继承关系(bean标签的parent属性),下面简单翻译一下:

    A bean definition can contain a lot of configuration information, 
    including constructor arguments, property values, and container-specific 
    information such as initialization method, static factory method name, and so on. 
    A child bean definition inherits configuration data from a parent definition. 
    The child definition can override some values, or add others, as needed. 
    Using parent and child bean definitions can save a lot of typing. 
    Effectively, this is a form of templating.

    我们知道,BeanDefinition是 bean标签的抽象,BeanDefinition和bean标签中的属性是一一对应的。BeanDefinition中存储大量的配置信息。子BeanDefinition能够从父BeanDefinition中继承配置信息。当然子BeanDefinition也可以覆盖或者新增一些新的配置信息。使用父子BeanDefinition能少打很多字(?),更加高效,这是一种模板方式。

    If you work with an ApplicationContext interface programmatically, 
    child bean definitions are represented by the ChildBeanDefinition class. 
    Most users do not work with them on this level, 
    instead configuring bean definitions declaratively in something like the ClassPathXmlApplicationContext. 
    When you use XML-based configuration metadata, 
    you indicate a child bean definition by using the parent attribute, 
    specifying the parent bean as the value of this attribute.

    在spring中,子BeanDefinition用ChildBeanDefinition表示。但是大家一般不这么使用,而是直接使用ClassPathXmlApplicationContext来配置BeanDefinition。
    当使用XML配置子BeanDefinition时,可以使用bean标签的parent属性来表示这个bean是个子bean。parent的属性值就是父bean。

    <bean id="inheritedTestBean" abstract="true"
            class="org.springframework.beans.TestBean">
        <property name="name" value="parent"/>
        <property name="age" value="1"/>
    </bean>
    
    <bean id="inheritsWithDifferentClass"
            class="org.springframework.beans.DerivedTestBean"
            parent="inheritedTestBean" init-method="initialize">
        <property name="name" value="override"/>
        <!-- the age property value of 1 will be inherited from parent -->
    </bean>
    A child bean definition uses the bean class from the parent definition if none is specified, 
    but can also override it. 
    In the latter case, the child bean class must be compatible with the parent, 
    that is, it must accept the parent’s property values.

    如果子bean的class没有指定,则使用使用父bean的class。如果子bean有指定class,则会覆盖父bean的class。后一种情况(子bean指定了class),子bean的class必须要和父bean的class兼容,也就是说能够接受父bean的配置。

    A child bean definition inherits scope, constructor argument values, 
    property values, and method overrides from the parent, with the option to add new values. 
    Any scope, initialization method, destroy method, 
    and/or static factory method settings that you specify will override the corresponding parent settings.

    子BeanDefinition继承父BeanDefinition的scorp、constructor 、property 、method overrides,并添加新配置。子BeanDefinition会覆盖父子BeanDefinition的配置有:initialization method、destroy method、static factory method settings。

    The remaining settings are always taken from the child definition: 
    depends on, autowire mode, dependency check, singleton, lazy init.

    子BeanDefinition有些配置始终不会继承父BeanDefinition:depends on、autowire mode、dependency check、singleton、lazy init。

    The preceding example explicitly marks the parent bean definition as abstract by using the abstract attribute. 
    If the parent definition does not specify a class, 
    explicitly marking the parent bean definition 
    as abstract is required, 
    as follows:
    <bean id="inheritedTestBeanWithoutClass" abstract="true">
        <property name="name" value="parent"/>
        <property name="age" value="1"/>
    </bean>
    
    <bean id="inheritsWithClass" class="org.springframework.beans.DerivedTestBean"
            parent="inheritedTestBeanWithoutClass" init-method="initialize">
        <property name="name" value="override"/>
        <!-- age will inherit the value of 1 from the parent bean definition-->
    </bean>

    前一个例子通过abstract属性将一个bean定义为抽象的。如果父bean没有指定class,则需要将其定义为抽象的。

    The parent bean cannot be instantiated on its own because it is incomplete, 
    and it is also explicitly marked as abstract. 
    When a definition is abstract like this, 
    it is usable only as a pure template bean definition that serves as a parent definition for child definitions. 
    Trying to use such an abstract parent bean on its own, 
    by referring to it as a ref property 
    of another bean or doing an explicit getBean() call with the parent bean id, returns an error. 
    Similarly, the container’s internal preInstantiateSingletons() method ignores 
    bean definitions that are defined as abstract.

    如果bean被定义为抽象,则不能初始化该bean。如果一个bean被指定为抽象,那么也就可以认为该bean就是一个模板,子bean通用配置的抽象。如果通过ref属性引用抽象bean,或者通过getBean获取抽象bean,则会返回错误。而且,spring的内部方法preInstantiateSingletons会忽略被定义为抽象的bean。

    二、获取RootBeanDefinition

    这里写图片描述

    如果缓存中不存在已经加载的单例bean,就需要从头开始bean的加载过程了。

    而加载bean的第一步就是获取bean的RootBeanDefinition,获取RootBeanDefinition的过程就是子bean合并父bean配置信息的过程

    我们知道bean标签在spring内部的表现的BeanDefinition。

    这里写图片描述

    回忆下,在注册bean标签的时候,不论是子bean还是父bean都是用的GenericBeanDefinition表示。子bean为什么不使用ChildBeanDefinition?

    进入ChildBeanDefinition源码,发现这样一段注释:

    NOTE:Since Spring 2.5, the preferred way to register bean definitions programmatically 
    is the {@link GenericBeanDefinition} class,which allows to dynamically define parent dependencies through the
    {@link GenericBeanDefinition#setParentName} method. This effectively
    supersedes the ChildBeanDefinition class for most use cases.

    从spring2.5起,注册bean的首选是GenericBeanDefinition,GenericBeanDefinition允许动态的定义父bean(通过setParentName方法)。

    下面分析代码:

    protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
            // Quick check on the concurrent map first, with minimal locking.
            //查看mergedBeanDefinitions集合中是否存在,如果存在直接返回。最小化的同步mergedBeanDefinitions
            RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
            if (mbd != null) {
                return mbd;
            }
            return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
        }
    protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
                throws BeanDefinitionStoreException {
    
            return getMergedBeanDefinition(beanName, bd, null);
        }
    protected RootBeanDefinition getMergedBeanDefinition(
                String beanName, BeanDefinition bd, BeanDefinition containingBd)
                throws BeanDefinitionStoreException {
    
            synchronized (this.mergedBeanDefinitions) {
                RootBeanDefinition mbd = null;
    
                // Check with full lock now in order to enforce the same merged instance.
                if (containingBd == null) {
                    mbd = this.mergedBeanDefinitions.get(beanName);
                }
    
                if (mbd == null) {
                    if (bd.getParentName() == null) {
                        // Use copy of given root bean definition.
                        if (bd instanceof RootBeanDefinition) {
                            mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
                        }
                        else {
                            mbd = new RootBeanDefinition(bd);
                        }
                    }
                    else {
                        // Child bean definition: needs to be merged with parent.
                        BeanDefinition pbd;
                        try {
                            String parentBeanName = transformedBeanName(bd.getParentName());
                            if (!beanName.equals(parentBeanName)) {
                                pbd = getMergedBeanDefinition(parentBeanName);
                            }
                            else {
                                BeanFactory parent = getParentBeanFactory();
                                if (parent instanceof ConfigurableBeanFactory) {
                                    pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
                                }
                                else {
                                    throw new NoSuchBeanDefinitionException(parentBeanName,
                                            "Parent name '" + parentBeanName + "' is equal 
                                            to bean name '" + beanName +
                                            "': cannot be resolved without an AbstractBeanFactory parent");
                                }
                            }
                        }
                        catch (NoSuchBeanDefinitionException ex) {
                            throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
                                    "Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
                        }
                        // Deep copy with overridden values.
                        mbd = new RootBeanDefinition(pbd);
                        mbd.overrideFrom(bd);
                    }
    
                    // Set default singleton scope, if not configured before.
                    if (!StringUtils.hasLength(mbd.getScope())) {
                        mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
                    }
    
                    // A bean contained in a non-singleton bean cannot be a singleton itself.
                    // Let's correct this on the fly here, since this might be the result of
                    // parent-child merging for the outer bean, in which case the original inner bean
                    // definition will not have inherited the merged outer bean's singleton status.
                    if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
                        mbd.setScope(containingBd.getScope());
                    }
    
                    // Only cache the merged bean definition if we're already about to create an
                    // instance of the bean, or at least have already created an instance before.
                    if (containingBd == null && isCacheBeanMetadata()) {
                        this.mergedBeanDefinitions.put(beanName, mbd);
                    }
                }
    
                return mbd;
            }
        }
    public BeanDefinition getMergedBeanDefinition(String name) throws BeansException {
            String beanName = transformedBeanName(name);
    
            // Efficiently check whether bean definition exists in this factory.
            if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
                return ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(beanName);
            }
            // Resolve merged bean definition locally.
            return getMergedLocalBeanDefinition(beanName);
        }

    一提到父子bean,那么代码中肯定就是递归。不断的合并父bean的配置。

    如果parentName 等于当前beanName,则需要到parentFactory中寻找parentName。如果找不到则抛出NoSuchBeanDefinitionException。

    如果beanName不存在当前beanFactory中,则取parentFactory中寻找。

    展开全文
  • Parent属性的另类用法

    千次阅读 2011-09-01 08:26:39
    Parent属性是用来控制控件的显示层次的,所有的TWinControl都有Parent属性,包括TForm。如果你设置TForm的Parent的为一个Panel,在整个Form就嵌入到Panel里了。 举一个应用的例子,假设你有一个配置界面,一个有很...
    Parent属性是用来控制控件的显示层次的,所有的TWinControl都有Parent属性,包括TForm。如果你设置TForm的Parent的为一个Panel,在整个Form就嵌入到Panel里了。 
    

    举一个应用的例子,假设你有一个配置界面,一个有很多Page的PageControl, 又假设每个Page的逻辑不太相干,如果所有代码都写在同一个单元里,读起来就很吃力。可以利用Form的Parent属性给每个Page都创建一个Form,然后把Form嵌入到Tabsheet中,这样PageControl仅是一个壳,每个Page的代码都是独立的。同样的原理很容易实现Tab标签类的结构。

    实际应用中可以去掉嵌入Form的边框,如下面的构造器:

    constructor TTAppBasicForm.CreateNestedForm(AOwner: TComponent; Container: TWinControl);
    begin
      inherited Create(AOwner);
      Parent := Container;
      BorderStyle := bsNone;
      WindowState := wsMaximized;
    end;

    这个技巧应该不限于Delphi,所有的基于Windows API的程序应该都可以使用。


    展开全文
  • Spring中bean标签中的parent属性

    千次阅读 2013-11-14 17:50:34
    parent属性最大的作用就是当很多bean都重用一些属性时,我们可以创建一个父亲bean,然后所有的bean都设定parent属性,引用父亲bean。
     parent属性最大的作用就是当很多bean都重用一些属性时,我们可以创建一个父亲bean,然后所有的bean都设定parent属性,引用父亲bean。
    展开全文
  • 关于如何 Spring注解的方式 指定parent属性 [问题点数:40分,结帖人xxgshxs]   不显示删除回复 显示所有回复  显示星级回复 显示得分回复  只显示楼主 收藏 xxgshxs xxgshxs...
  • Spring bean里的parent属性

    千次阅读 2012-09-07 14:42:53
    有一个Test的类,里面有User属性和setUser(User user)方法,现在用Spring的IOC,使用到bean里的parent属性。 ... bean id="testProxy" class="org.springframework.transaction.interceptor....
  • 使用data-parent属性的时候须使用 .panel类,具体要求: panel类必须是 data-parent这个父容器的直接子元素 collapse类必须是 panel类的直接子元素
  • vue的$parent属性

    千次阅读 2020-07-01 15:58:59
    这上面有很多的属性,我们比较常用的 有$refs , $attrs, tips: 我们绑定的时候应该是单数形式比如: $ref 获取时候应该是复数形式。 2. $refs 让我们可以在父组件中进行操作子组件的数据以及方法。 $parents 让我们...
  • 问题:在游客模式下可以进入到该iframe中,当点击提交()时,将超链接中加入 target=_parent属性 ,是使其以向父级页面跳转进入登录界面,已登录模式下消除该属性。结果是:游客模式下还在当前iframe内跳转向登录界面...
  • Spring的bean标签的scope和parent属性

    千次阅读 2011-11-20 12:19:50
    1. bean parent:parent属性最大的作用就是当很多bean都重用一些属性时,我们可以创建一个父亲bean,然后所有的bean都设定parent属性,引用父亲bean。最常见的配置就是在配置transactionManager的时候。 2. ...
  • 1.在bean中配置abstract属性为”true”,则spring容器不会为该类创建对象。 张三"></property> </bean> 2.在bean中配置parent属性,则可以让
  • spring bean parent属性详解

    千次阅读 2017-05-26 22:05:32
    必要条件:1、子bean必须与父bean保持兼容,也就是说子bean中必须有父bean定义的所有属性。  2、父bean必须是抽象bean或者定义lazy-init=true也就是不让bean工厂实例化该bean 注:好多人将parent指向的类说是...
  • 一个窗口的window.parent属性总不为空

    千次阅读 2009-03-31 14:27:00
    一个窗口的window.parent属性总不为空
  • 在实例化布局时不能使用如下格式: View convertView = LayoutInflater.from(context).inflate(context, R....View convertView = mInflater.from(context).inflate(R.layout.***, parent, false); 如果在自定...
  • 一个bean定义可能会包含大量的配置信息,包括容器相关的信息(比如初始化方法,静态工厂方法等等)以及构造函数参数和属性的值。一个child bean定义是一个能够从parent bean定义继承配置数据的bean定义。然后它...
  • 最近 自定义Dialog 的时候 发现给Dialog 中显示的Layout 设置为width="match_parent" 后, 在手机中显示 布局完全没有根据屏幕宽度进行... true 这属性 造成 设置的Layout 的宽度 设置为match_parent 失效。 去掉就
  • frameLayout child的 match-parent属性问题

    千次阅读 2015-11-02 14:24:35
    现在有一个需求 --- --- ...Button的宽度 也是Math-parent的宽度 即外层宽度适配ImageView的宽度。 同时想让Button的宽度与FrameLayout的宽度一致 但是实际运行的时候 发现Button
  • 之前用RecyclerView为了达到自己想要的结果,把item的根布局(最外层Layout)的大小设为match_parent,一开始却发现一个很大的问题!咦?为什么我的item一加载就成了wrap_content的效果?我的match_parent为什么效果...
  • 第二步:来到子页面中,定义调用Parent属性的方法,在通过该属性调用父页面的方法时要注意一点,为以防万一,应当在调用前进行一次if判断,判断parent是否存在,确认存在了再进行调用: //点击选择客户按钮,调用...
  • 解决方案:  1. item使用RelativeLayout布局,并且布局中的view至少有一个layout_alignParentRight=true  2. 在adapte中的...public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) { //

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 405,198
精华内容 162,079
关键字:

parent属性