spring -- 2、springIOC_spring ioc 获取ioc容器中的具体对象,需要强制类型转换-程序员宅基地

技术标签： spring springIOC springioc 后端

1、

1.2：

1.3：解决在1和2中“用户服务”重复添加代码比较麻烦的问题（因为只允许开一个）

1.4、

2、IOC控制反转：（设计思想：通过中介）

2.1、跟上面的第三方相似

2.2、DI与IOC：

2.3、图

2.4、spring每个绿框都是对应不同模块：

3.4.3、对命名空间为bean的标签进行赋值，简化配置文件中属性声明的写法：

3.4.4、为复杂类型进行赋值操作

3.4.5、继承关系bean的配置（bean之间的继承关系）

3.4.6、 bean对象创建的依赖关系

3.4.7、 bean的作用域控制，是否是单例

3.4.8、利用工厂模式创建bean对象

3.4.9、继承FactoryBean（工厂豆）来创建对象

3.4.10、 bean对象的初始化和销毁方法

3.4.11、配置bean对象初始化方法的前后处理方法

1、

普通创建项目方式：

java文件：UserDao（用户访问接口）

public interface UserDao {
    public void getUser();
}

java文件： UserDaoImpl（用户访问）

public class UserDaoImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("获取用户");    }
}

java文件：UserService（用户服务接口）

public interface UserService {
    public void getUser();
}

java文件：UserServiceImpl（用户服务）

public class UserServiceImpl implements UserService {
============================= 1、 ===================================
//    private UserDao userDao = new UserDaoImpl(); //只能开一个
============================= 2、 ===================================
//    private UserDao userDao = new UserDaoMysqlImpl(); //只能开一个
============================= 3、 ===================================
    private UserDao userDao;
    public void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }
=====================================================================
    @Override
    public void getUser() {
        userDao.getUser();
    }
}

java文件：MyText（测试）

public class MyTest {
    public static void main(String[] args) {
============================= 1、 ===================================
        UserServiceImpl userService = new UserServiceImpl();
        userService.getUser();
============================= 3、 ===================================
第三方：UserDaoMysqlImpl userDaoMysql = new UserDaoMysqlImpl();
        userService.setUserDao(userDaoMysql);
        userService.getUser();
============================= 4、 ===================================
        userService.getUser();
        System.out.println("--------------");
        UserDaoOracleImpl userDaoOracle = new UserDaoOracleImpl();
        userService.setUserDao(userDaoOracle);
        userService.getUser();
=====================================================================
    }
}

（四种获取方式）

都是：

1.2：

java文件：UserDaoMysqlImpl（用户访问Mysql）

public class UserDaoMysqlImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("从mysql获取数据");
    }
}

1.3：解决在1和2中“用户服务”重复添加代码比较麻烦的问题（因为只允许开一个）

1.4、

java文件：UserDaoOracleImpl（用户访问Oracle）

public class UserDaoOracleImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("从oracle中获取数据");
    }
}

2、IOC控制反转：（设计思想：通过中介）

2.1、跟上面的第三方相似

1、谁控制谁：在之前的编码过程中，都是需要什么对象自己去创建什么对象，有程序员自己来控制对象，而有了IOC容器之后，就会变成由IOC容器来控制对象，
2、控制什么：在实现过程中所需要的对象及需要依赖的对象
3、什么是反转：在没有IOC容器之前我们都是在对象中主动去创建依赖的对象，这是正转的，而有了IOC之后，依赖的对象直接由IOC容器创建后注入到对象中，由主动创建变成了被动接受，这是反转
4、哪些方面被反转：依赖的对象

2.2、DI与IOC：

很多人把IOC和DI说成一个东西，笼统来说的话是没有问题的，但是本质上还是有所区别的,希望大家能够严谨一点，IOC和DI是从不同的角度描述的同一件事，IOC是从容器的角度描述，而DI是从应用程序的角度来描述，也可以这样说，IOC是设计思想，而DI是具体的实现方式

2.3、图

解决方式→

无论是架构师还是程序员，在面临这样的场景的时候，都需要减少这些对象的耦合性：

从上图中可以看到，当引入了第三方的容器之后，几个对象之间就没有了耦合关系，全部对象都交由容器来控制，这个容器就相当于粘合剂，将系统的对象粘合在一起发挥作用。

2.4、spring每个绿框都是对应不同模块：

从下往上创建：

Core Container（IOC反转）

3、

3.1、测试：

导入包后，里面会多出一个选项

java文件：Person（个人）

private int id;
    private String name;
    private int age;
    private String gender;

    public Person() {
        System.out.println("person被创建");
    }
    public int getId() {return id;}
    public void setId(int id) {this.id = id;}

    public String getName() {return name;}
    public void setName(String name) {this.name = name;}

    public int getAge() {return age;}
    public void setAge(int age) {this.age = age;}

    public String getGender() {return gender;}
    public void setGender(String gender) {this.gender = gender;}

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }
}

xml文件：ioc

bean标签：表示要创建的bean对象
id:唯一标识，为了跟其他的bean标签区分
class:表示要创建的bean的完全限定名

property标签：给属性赋值使用
name:表示属性的名称
value：表示具体的属性值

<bean id="person" class="com.mashibing.bean.Person">
    <property name="id" value="1"></property>
    <property name="name" value="zhangsan"></property>
    <property name="age" value="20"></property>
    <property name="gender" value="男"></property>
 </bean>

java文件：MyText（测试）

ApplicationContext:表示IOC容器的入口，想要获取对象的话，必须要创建该类
该类有两个读取配置文件的实现类（相当于中介）：
ClassPathXmlApplicationContext:表示从classpath中读取数据
FileSystemXmlApplicationContext:表示从当前文件系统读取数据

public class MyTest {
    public static void main(String[] args) {
        //Person person = new Person();
        //System.out.println(person);

        ApplicationContext context = new ClassPathXmlApplicationContext("ioc.xml");
//获取具体的bean实例对象，需要进行强制类型转换
        //Person person = (Person) context.getBean("person");

//获取对象的时候不需要强制类型转换
        Person person = context.getBean("person", Person.class);
        System.out.println(person);

}
}

容器中的person对象是什么时候创建的？
容器中的对象在容器创建完成之前就已经把对象创建好了

3.2、maven仓库的分类：

本地仓库：本地仓库就是开发者本地已经下载下来的或者自己打包所有jar包的依赖仓库，本地仓库路径配置在maven对应的conf/settings.xml配置文件。

私有仓库：私有仓库可以理解为自己公司的仓库，也叫Nexus私服

中央仓库：中央仓库即maven默认下载的仓库地址，是maven维护的

说明：私有仓库需要每天维护，将外面与内部相关的信息、地址不断修改

maven常用命令：

clean：清理编译后的目录
compile：编译，只编译main目录，不编译test中的代码
test-compile：编译test目录下的代码
test：运行test中的代码
package：打包，将项目打包成jar包或者war包
install：发布项目到本地仓库用在打jar包上，打成的jar包可以被其他项目使用
deploy：打包后将其安装到pom文件中配置的远程仓库
site：生成站点目录

3.3、创建文件：

打开：

3.4、

3.4.1、获取属性：

java文件：Person（个人）

private int id;
    private String name;
    private int age;
    private String gender;
========================= 利用的是构造器 ============================
    public Person() {
        System.out.println("person被创建");
    }
=====================================================================
    public int getId() {return id;}
    public void setId(int id) {this.id = id;}

    public String getName() {return name;}
    public void setName(String name) {this.name = name;}

    public int getAge() {return age;}
    public void setAge(int age) {this.age = age;}

    public String getGender() {return gender;}
    public void setGender(String gender) {this.gender = gender;}

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }
}

xml文件：ioc

<bean id="parent" class="com.mashibing.bean.Person" abstract="false"> 
        <property name="id" value="1"></property>
        <property name="name" value="zhangsan"></property>
        <property name="age" value="20"></property>
        <property name="gender" value="男"></property>
    </bean>

java文件：Mytest（测试）

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("ioc.xml");
        /*根据bean标签的id来获取对象*/
     Person person = context.getBean("person", Person.class);
     System.out.println(person);

========================= 2、（多例模式）============================
     //Person person2 = context.getBean("person",Person.class);
     //System.out.println(person == person2);  
=====================================================================

//上面是通过id：person获取属性
//下面是直接获取整个类的属性（如果存在同名的id会报错）
     //Person bean = context.getBean(Person.class);
     //System.out.println(bean);

细节点：

1、对象在Spring容器创建完成的时候就已经创建完成，不是需要用的时候才创建，这种情况值满足单例模式 （容器中创建）

2、单例与多例

3、给属性赋值的时候是通过容器中的set方法实现的

4、对象的属性是由set/get方法决定的，而不是定义的成员属性

总结：获取属性的三种方式：

1、（之前已经讲了）

2、ApplicationContext，通过id：person获取属性

3、ApplicationContext，通过类整个类获取属性

3.4.2、通过构造器给对象赋值：

java文件：Person（个人）

添加构造器：

public Person(int id, String name, Integer age, String gender) {
    this.id = id;
    this.name = name;
    this.age = age;
    this.gender = gender;
}

xml文件：ioc

方式一：

<bean id="person2" class="com.mashibing.bean.Person">
    <constructor-arg name="id" value="2"></constructor-arg>
    <constructor-arg name="name" value="lisi"></constructor-arg>
    <constructor-arg name="age" value="22"></constructor-arg>
    <constructor-arg name="gender" value="男"></constructor-arg>
</bean>

方式二：（前面讲了）

方式三：

（位置交换）（结果的位置也交换）

java文件：Mytest（测试）

xml文件：ioc（但是要注意里面的顺序，如果顺序不一致的话，可以用index索引到那个值）

<bean id="person3" class="com.mashibing.bean.Person">
    <constructor-arg  value="2"></constructor-arg>
    <constructor-arg  value="男" index="3"></constructor-arg>
    <constructor-arg  value="22"></constructor-arg>
    <constructor-arg  value="lisi" index="1"></constructor-arg>
</bean>

name:表示参数列表的名称
value:表示实际的具体值
type:表示值的类型
index:表示值的下标，从0开始

==========================================

java文件：Person（个人）创建有参构造方法：

java文件：Mytest（测试）

xml文件：ioc

<bean id="person4" class="com.mashibing.bean.Person">
    <constructor-arg  value="4"></constructor-arg>
    <constructor-arg  value="wangwu"></constructor-arg>
    <constructor-arg  value="22" type="java.lang.Integer">
</constructor-arg>
</bean>

先执行下面构造函数，执行是有顺序的：

//构造方法交换位置：

解决办法：（一般用在id后面）

总结：

在日常工作中，一般都是用name,value的方式，很少有人去使用index或者type的方式，但是要注意各种情况出现的问题

3.4.3、对命名空间为bean的标签进行赋值，简化配置文件中属性声明的写法：

xml文件：ioc

1、导入命名空间：

2、添加配置：

使用p命名空间来给属性赋值：

<bean id="person5" class="com.mashibing.bean.Person" 
p:id="5" 
p:name="wangwu"
p:age="25" 
p:gender="女">
</bean>

java文件：Mytest（测试）

Person person5 = context.getBean("person5", Person.class);
System.out.println(person5);

3.4.4、为复杂类型进行赋值操作

java文件：Person（个人）

public class Person {
    private int id;
    private String name;
    private Integer age;
    private String gender;    
=========================== 从这里开始 ==============================
    private String[] hobbies; 1、 数组
    private Address address;  2、 引用

    private List<Address> lists; 3、 获取对象的值
    private Set<String> sets;    4、 给数组赋值
    private Map<String,Object> maps; 5、 赋值
    private Properties properties;   6、 赋值

    //public Person() {System.out.println("person被创建");}
    public Person(int id, String name, Integer age, String gender) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    public Person(int id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
        System.out.println("age......");
    }
    public Person(int id, String name, String gender) {
        this.id = id;
        this.name = name;
        this.gender = gender;
        System.out.println("gender.....");
    }
    public int getId() {return id;}
    public void setId(int id) {this.id = id;}

    public String getName() {return name;}
    public void setName(String name) {this.name = name;}

    public Integer getAge() {return age;}
    public void setAge(Integer age) {this.age = age;}

    public String getGender() {return gender;}
    public void setGender(String gender) {this.gender = gender;}

    public String[] getHobbies() {return hobbies;}
    public void setHobbies(String[] hobbies){this.hobbies = hobbies;}

    public Address getAddress() {return address;}
    public void setAddress(Address address) {this.address = address;}

    public List<Address> getLists() {return lists;}
    public void setLists(List<Address> lists) {this.lists = lists;}

    public Set<String> getSets() {return sets;}
    public void setSets(Set<String> sets) {this.sets = sets;}

    public Map<String, Object> getMaps() {return maps;}
    public void setMaps(Map<String, Object> maps) {this.maps = maps;}

    public Properties getProperties() {return properties;}
    public void setProperties(Properties properties) {
        this.properties = properties;
    }
    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", hobbies=" + Arrays.toString(hobbies) +
                ", address=" + address +
                ", lists=" + lists +
                ", sets=" + sets +
                ", maps=" + maps +
                ", properties=" + properties +
                '}';
    }
}

java文件：Address（住址）

public class Address {
    private String province; //省
    private String city; //市
    private String town; //城

    public Address() {System.out.println("address被创建");}
    public String getProvince() {return province;}
    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {return city;}
    public void setCity(String city) {this.city = city;}

    public String getTown() {return town;}
    public void setTown(String town) {this.town = town;}
    @Override
    public String toString() {
        return "Address{" +
                "province='" + province + '\'' +
                ", city='" + city + '\'' +
                ", town='" + town + '\'' +
                '}';
    }
}

java文件：Mytest（测试）

    Person person6 = context.getBean("person6", Person.class);
    System.out.println(person6);

xml文件：ioc

<bean id="person6" class="com.mashibing.bean.Person">
        <property name="id" value="6"></property>
        <property name="name" value="zhangsan6"></property>
        <property name="age" value="26"></property>
        <property name="gender" value="男6"></property>
=============================== 1、 =================================

//给数组赋值

方式一：<property name="hobbies" value="book,girl,movie"></property>
方式二：<property name="hobbies">
            <array>
                <value>book</value>
                <value>girl</value>
                <value>movie</value>
            </array>
        </property>
=============================== 2、 =================================
//给引用类型赋值,可以使用ref引入外部bean
//address（住址类），ref（引用）
        <bean id="address" class="com.mashibing.bean.Address">
            <property name="address" ref="address"></property></bean>

            <property name="lists" value="1,2,3"></property>

        </bean>
        <bean id="address" class="com.mashibing.bean.Address">
            <property name="province" value="河北省"></property>
            <property name="city" value="邯郸"></property>
            <property name="town" value="武安"></property>
        </bean>
=============================== 3、 =================================
        <property name="lists">
           <list>
//使用内部bean,无法从IOC容器中直接获取对象的值（<bean后面不能加id="address2"）
              <bean class="com.mashibing.bean.Address">
                   <property name="province" value="北京"></property>
              </bean>
              <bean class="com.mashibing.bean.Address">
                   <property name="province" value="上海"></property>
              </bean>

=====================================================================
//使用外部bean，可以随意从IOC容器获取对象的值（随意）
              <ref bean="address"></ref>

           </list>
        </property>
=============================== 4、 =================================
//给set属性赋值
        <property name="sets">
            <set>
                <value>zhangsan</value>
                <value>zhangsan</value>
                <value>lisi</value>
            </set>
        </property>

=============================== 5、 =================================
//给map赋值
        <property name="maps">
            <map>
                <entry key="a" value="aaa"></entry>
//引用：--------<entry key="address" value-ref="address"></entry>
                <entry key="address2">
//在自己内部创建对象<bean class="com.mashibing.bean.Address">
                        <property name="province" value="广东省">
</property>
                    </bean>
                </entry>

               <entry>              
                    <key>
                        <value>heihei</value>
                    </key>
                    <value>haha</value>
                </entry>

                <entry key="list">                
                    <list>
                        <value>11</value>
                        <value>22</value>
                    </list>
                </entry>
            </map>
        </property>

也可用利用文档方式：

3.4.5、继承关系bean的配置（bean之间的继承关系）

如果想实现Java文件的抽象类，不需要将当前bean实例化的话，可以使用abstract属性

xml文件：ioc

//可以使用abstract标签定义抽象bean，但无法进行实例化
<bean id="parent" class="com.mashibing.bean.Person" abstract="false">
    <property name="id" value="1"></property>
    <property name="name" value="zhangsan"></property>
    <property name="age" value="20"></property>
    <property name="gender" value="男"></property>
</bean>

//可以通过parent属性来获取父bean中的某些属性值
<bean id="son" class="com.mashibing.bean.Person" parent="parent">
    <property name="name" value="haha"></property>
</bean>

java文件：Mytest（测试）

    Person son = context.getBean("son", Person.class);
    System.out.println(son);

ico.xml中添加：parent="parent"

java文件：Mytest（测试）

    Person parent = context.getBean("parent", Person.class);
    System.out.println(parent);

ico.xml中添加：abstract="false"（teun是用于实例化）

3.4.6、 bean对象创建的依赖关系

添加：

xml文件：ioc

如果需要干扰创建的顺序，可以使用depends-on属性

    <bean id="address" class="com.mashibing.bean.Address" depends-on
="person"></bean>
    <bean id="person" class="com.mashibing.bean.Person"></bean>

//

（ioc.xml代码的顺序与该顺序是相关的）

3.4.7、 bean的作用域控制，是否是单例

bean的作用域：singleton、prototype、request、session

默认情况下是单例

singleton（单例）：默认的单例对象，IOC容器启动完成之前就已经创建好对象,获取的都是同一个对象

prototype（多例）：多实例

IOC容器启动的时候不会创建多实例bean，只有在获取对象的时候才会创建该对象，每次创建都是一个新的对象

另外两个作用域：request、session（在spring5.x的版本就去掉了）

request（请求）：每次发送请求都会有一个新的对象

session：（会话）每一个会话都会有一个新的对象（默认是30分钟，不做任何操作会消失）

xml文件：ioc

//设置bean对象的作用域
    <bean id="person2" class="com.mashibing.bean.Person" scope(范围)=
"singleton"></bean>

java文件：Mytest（测试）

    Person parent2 = context.getBean("parent2", Person.class);
Person parent3 = context.getBean("parent3", Person.class);
    System.out.println(parent2 == parent3);

换成：scope(范围)="prototype"时，为

（上面java代码需要用到，person就立即创建）

singleton（单例）：每次在创建IOC容器完成之前此对象已经创建完成

prototype（多例）：每次是在需要用到此对象的时候才会创建

3.4.8、利用工厂模式创建bean对象

在利用工厂模式创建bean实例的时候有两种方式：

静态工厂：工厂本身不需要创建对象，但是可以通过静态方法调用

对象 = 工厂类.静态工厂方法名（）；

实例工厂：工厂本身需要创建对象

工厂类工厂对象 = new 工厂类；

工厂对象.get对象名（）；

java文件：PersonStaticFactory（静态工厂）

public class PersonStaticFactory {
    public static Person getInstance(String name){
        Person person = new Person();
        person.setId(1);
        person.setName(name);
        person.setAge(11);
        return person;
    }
}

java文件：PersonInstanceFactory（实例工厂）

public class PersonInstanceFactory {
    public Person getInstance(String name){
        Person person = new Person();
        person.setId(2);
        person.setName(name);
        person.setAge(22);
        return person;
    }
}

xml文件：ioc

============================ 静态工厂 ===============================
    <bean id="person2" class="com.mashibing.bean.Person" scope=
"singleton">
</bean>

//利用工厂方法创建bean
//静态工厂：类名.静态方法（）
//factory-bean:工厂类的实例
//factory-method:工厂实例的方法

    <bean id="person" class=
"com.mashibing.factory.PersonStaticFactory" factory-method=
"getInstance"> //getInstance工厂方法
        <constructor-arg value="zhangsan"></constructor-arg>
    </bean>

============================ 实例工厂 ===============================
//实例工厂：先创建工厂实例，然后调用工厂实例的方法

    <bean id="instanceFactory(实例工厂)" class=
"com.mashibing.factory.PersonInstanceFactory"></bean>
    <bean id="person2" class="com.mashibing.bean.Person" 
factory-bean="instanceFactory(实例工厂)" factory-method="getInstance"> //getInstance工厂方法
        <constructor-arg value="lisi"></constructor-arg>
    </bean>

java文件：MyText（测试）

============================ 静态工厂 ===============================
Person person = context.getBean("person", Person.class);
    System.out.println(person);
============================ 实例工厂 ===============================
Person person2 = context.getBean("person2", Person.class);
    System.out.println(person);

3.4.9、继承FactoryBean（工厂豆）来创建对象

Spring都会将其作为一个工厂，但是在ioc容器启动的时候不会创建实例，只有在使用的时候才会创建对象（相当于prototype多例）

java文件：MyFactoryBean（工厂豆）

public class MyFactoryBean implements FactoryBean<Person> {
//返回获取的bean
    public Person getObject() throws Exception {
        Person person = new Person();
        person.setId(3);
        person.setName("王五");
        return person;
    }
//获取返回bean的类型
    public Class<?> getObjectType() {
        return Person.class;
    }
//判断当前bean是否是单例的
    public boolean isSingleton() {
        return true;
    }
}

xml文件：ioc

    <bean id="myFactoryBean" class=
"com.mashibing.factory.MyFactoryBean">
    </bean>

java文件：MyText（测试）

Person myFactoryBean = context.getBean("myFactoryBean",Person.class);
System.out.println(myFactoryBean);

3.4.10、 bean对象的初始化和销毁方法

java文件：Person（个人）

public void init(){
·
·
·
//编写N行逻辑代码完成初始化功能
    System.out.println("person对象初始化完成");
}
public void destory(){
    System.out.println("person对象被销毁");
}

xml文件：ioc

spring容器在创建对象的时候可以指定具体的初始化和销毁方法：
init-method:在对象创建完成之后会调用初始化方法
destory-method:在容器关闭的时候会调用销毁方法

<bean id="person" class="com.mashibing.bean.Person"
init-method="init(初始化)" destroy-method="destory(销毁)" scope="singleton(单例)"> 

初始化和销毁的方法跟scope属性也是相关联的：
如果是singleton(单例)的话，初始化和销毁的方法都显示
如果是prototype(多例)的话，初始化方法会调用，但是销毁的方法不会显示

java文件：MyText（测试）

Person person = context.getBean("person", Person.class);
    System.out.println(person);
//一般关闭对象用：context.close();

因为context对应ioc文件

//但是这里关闭用的是另一种：

  ((ClassPathXmlApplicationContext)context).close();

3.4.11、配置bean对象初始化方法的前后处理方法

spring中包含一个BeanPostProcessor的接口，可以在bean的初始化方法的前后调用该方法，如果配置了初始化方法的前置和后置处理器，无论是否包含初始化方法，都会进行调用

java文件：MyBeanPostProcessor（豆布置处理器）

public class MyBeanPostProcessor implements BeanPostProcessor {
    /**
     * 在每一个对象的初始化方法前面执行
     * @param bean:表示创建的具体对象
     * @param beanName:表示bean的id属性
     * @return
     * @throws BeansException
     */
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

System.out.println("postProcessBeforeInitialization:"+beanName);
        return bean;
    }
    /**
     * 在每一个对象的初始化方法后面执行
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

System.out.println("postProcessAfterInitialization:"+beanName);
     return bean;
    }
}

xml文件：ioc

<bean id="myBeanPostProcessor" class="com.mashibing.bean.MyBeanPostProcessor">
</bean>

<bean id="aAddress" class="com.mashibing.bean.Address"></bean>

本文链接：https://blog.csdn.net/weixin_45042569/article/details/107227088

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

51单片机的中断系统_51单片机中断篇-程序员宅基地

文章浏览阅读3.3k次，点赞7次，收藏39次。CPU 执行现行程序的过程中，出现某些急需处理的异常情况或特殊请求，CPU暂时中止现行程序，而转去对异常情况或特殊请求进行处理，处理完毕后再返回现行程序断点处，继续执行原程序。void 函数名(void) interrupt n using m {中断函数内容 //尽量精简 }编译器会把该函数转化为中断函数，表示中断源编号为n，中断源对应一个中断入口地址，而中断入口地址的内容为跳转指令，转入本函数。using m用于指定本函数内部使用的工作寄存器组，m取值为0~3。该修饰符可省略，由编译器自动分配。_51单片机中断篇

oracle项目经验求职,网络工程师简历中的项目经验怎么写-程序员宅基地

文章浏览阅读396次。项目经验(案例一)项目时间：2009-10 - 2009-12项目名称：中驰别克信息化管理整改完善项目描述：项目介绍一，建立中驰别克硬件档案(PC,服务器，网络设备，办公设备等)二，建立中驰别克软件档案(每台PC安装的软件，财务，HR，OA，专用系统等)三，能过建立的档案对中驰别克信息化办公环境优化(合理使用ADSL宽带资源，对域进行调整，对文件服务器进行优化，对共享打印机进行调整)四，优化完成后..._网络工程师项目经历

LVS四层负载均衡集群-程序员宅基地

文章浏览阅读1k次，点赞31次，收藏30次。LVS：Linux Virtual Server，负载调度器，内核集成，阿里的四层SLB(Server Load Balance)是基于LVS+keepalived实现。NATTUNDR优点端口转换WAN性能最好缺点性能瓶颈服务器支持隧道模式不支持跨网段真实服务器要求anyTunneling支持网络private（私网）LAN/WAN（私网/公网）LAN（私网）真实服务器数量High (100)High (100)真实服务器网关lvs内网地址。

「技术综述」一文道尽传统图像降噪方法_噪声很大的图片可以降噪吗-程序员宅基地

文章浏览阅读899次。https://www.toutiao.com/a6713171323893318151/作者 | 黄小邪/言有三编辑 | 黄小邪/言有三图像预处理算法的好坏直接关系到后续图像处理的效果，如图像分割、目标识别、边缘提取等，为了获取高质量的数字图像，很多时候都需要对图像进行降噪处理，尽可能的保持原始信息完整性（即主要特征）的同时，又能够去除信号中无用的信息。并且，降噪还引出了一..._噪声很大的图片可以降噪吗

Effective Java 【对于所有对象都通用的方法】第13条谨慎地覆盖clone_为继承设计类有两种选择,但无论选择其中的-程序员宅基地

文章浏览阅读152次。目录谨慎地覆盖cloneCloneable接口并没有包含任何方法，那么它到底有什么作用呢？Object类中的clone()方法如何重写好一个clone()方法1.对于数组类型我可以采用clone()方法的递归2.如果对象是非数组，建议提供拷贝构造器（copy constructor）或者拷贝工厂（copy factory）3.如果为线程安全的类重写clone()方法4.如果为需要被继承的类重写clone()方法总结谨慎地覆盖cloneCloneable接口地目的是作为对象的一个mixin接口（详见第20_为继承设计类有两种选择,但无论选择其中的

毕业设计基于协同过滤的电影推荐系统-程序员宅基地

文章浏览阅读958次，点赞21次，收藏24次。今天学长向大家分享一个毕业设计项目基于协同过滤的电影推荐系统项目运行效果：项目获取：https://gitee.com/assistant-a/project-sharing21世纪是信息化时代，随着信息技术和网络技术的发展，信息化已经渗透到人们日常生活的各个方面，人们可以随时随地浏览到海量信息，但是这些大量信息千差万别，需要费事费力的筛选、甄别自己喜欢或者感兴趣的数据。对网络电影服务来说，需要用到优秀的协同过滤推荐功能去辅助整个系统。系统基于Python技术，使用UML建模，采用Django框架组合进行设

随便推点

你想要的10G SFP+光模块大全都在这里-程序员宅基地

文章浏览阅读614次。10G SFP+光模块被广泛应用于10G以太网中，在下一代移动网络、固定接入网、城域网、以及数据中心等领域非常常见。下面易天光通信（ETU-LINK）就为大家一一盘点下10G SFP+光模块都有哪些吧。一、10G SFP+双纤光模块10G SFP+双纤光模块是一种常规的光模块，有两个LC光纤接口，传输距离最远可达100公里，常用的10G SFP+双纤光模块有10G SFP+ SR、10G SFP+ LR，其中10G SFP+ SR的传输距离为300米，10G SFP+ LR的传输距离为10公里。_10g sfp+

计算机毕业设计Node.js+Vue基于Web美食网站设计(程序+源码+LW+部署)_基于vue美食网站源码-程序员宅基地

文章浏览阅读239次。该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：项目技术：Express框架 + Node.js+ Vue 等等组成，B/S模式 +Vscode管理+前后端分离等等。环境需要1.运行环境：最好是Nodejs最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发环境：Vscode或HbuilderX都可以。推荐HbuilderX;3.mysql环境：建议是用5.7版本均可4.硬件环境：windows 7/8/10 1G内存以上；_基于vue美食网站源码