Spring-1-（简介及HelloWord）

//以往我们需要自己手动的创建对象，并进行使用
User user = new User();
String address = user.getAddress();//现在我们只需要将spring容器中的对象拿出来使用就好了
@Autowired
User user;
String address1 = user.getAddress();

<bean class="com.xpl.model.User" id="user">

public class Text {
public static void main(String[] args) {
// 将applicationContext加载进去，初始化spring容器
// spring初始化的时候就会将容器中的所有组件初始化，这个时候对象已将创建
// 他是通过类的无参构造进行初始化的
ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
// 获取spring容器中的组件
// 方式有三种：
// 方式一：通过id获取，但是要强转
// User user = (User) cxt.getBean("user");
// 方式二：通过id和类获取
User user = cxt.getBean("user4", User.class);
System.out.println(user);
// 方式三：通过class类获取，有个缺陷，加入spring中使用这个类创建了多个实例，就会冲突，找不到
User bean = cxt.getBean(User.class);
String[] beanDefinitionNames = cxt.getBeanDefinitionNames();
// 可以看到spring容器中所有的组件名字
for(int i=0;i<beanDefinitionNames.length;i++){
System.out.println(beanDefinitionNames[i]);
}
}
}

<!--通过构造器注入bean-->
<bean class="com.xpl.model.User" id="user">
<constructor-arg index="0" value="张三"/>
<constructor-arg index="1" value="27"/>
</bean>
<!--结果-->
<!--有参构造String name, int age-->
<!--User{name='张三', age=27}-->
<bean class="com.xpl.model.User" id="user1">
<constructor-arg name="name" value="李四"/>
<constructor-arg name="age" value="27"/>
</bean>
<!--结果-->
<!--有参构造int age,String name-->
<!--User{name='李四', age=27}-->
<!--发现：走的是后边（有两个有参构造，第二个有参构造）-->
<!--是因为通过有参构造，name属性赋值时候，执行参数相同的构造器的最后一个）-->
<!--这个时候就需要使用参数中的index或者type来精准定位-->
<!--注意不需要全都写，配合使用只要能定位到某个构造器就可以-->
<bean class="com.xpl.model.User" id="user2">
<constructor-arg name="name" index="0" value="王五"/>
<constructor-arg name="age" value="27"/>
</bean>
<!--结果-->
<!--有参构造String name, int age-->
<!--User{name='王五', age=27}--><!--实例工厂创建-->
<!--实例工厂需要实例化，所以先注入进来-->
<bean class="com.xpl.model.UserFactory" id="userFactory"/>
<!--指定实例工厂是哪一个，在指定工厂方法是哪一个-->
<bean factory-bean="userFactory" factory-method="creatPeople" id="user3"/><!--静态工厂创建-->
<bean class="com.xpl.model.UserStaticFactory" factory-method="creatPeople" id="user4"/>

<bean class="com.xpl.model.User" id="user">
<!--基本数据类型-->
<property name="name" value="赵六"/>
<!--数组-->
<property name="arr">
<array>
<value>1</value>
<value>2</value>
<value>3</value>
</array>
</property>
<!--如果list中只有一个值也可以这样写-->
<!--<property name="arr" value="1"/>-->
<!--引用数据类型，引用上边的cat-->
<property name="cat" ref="cat"/>
<!--list-->
<property name="list">
<list>
<value>5</value>
<value>6</value>
<value>7</value>
</list>
</property>
<!--如果list中只有一个值也可以这样写-->
<!--<property name="list" value="1"/>-->
<!--map-->
<property name="map">
<map>
<entry key="1" value="2"/>
<entry key="2" value="2"/>
<entry key="3" value="2"/>
</map>
</property>
<property name="set">
<set>
<value>1</value>
<value>2</value>
<value>3</value>
</set>
</property>
<property name="properties">
<props>
<prop key="1">1</prop>
<prop key="2">2</prop>
<prop key="3">3</prop>
</props>
</property>
</bean>

//首先有一个bean，这个Bean就是下边Bean的一个属性
<bean class="com.xpl.model.User" id="user">
<property name="cat" ref="cat"/>
</bean>
<bean class="com.xpl.model.Cat" id="cat">
//这个Bean中的属性是一个Bean
<property name="name" value="小白猫"/>
</bean>

public class User {
private Cat cat;
private Properties properties;
}public class Cat {
private String name;
}

public interface Calculate {
public int add(int a,int b);
public int min(int a,int b);
}public class Calculateimpl implements Calculate {
@Override
public int add(int a, int b) {
return a+b;
} @Override
public int min(int a, int b) {
return a-b;
}
}public class ProxyFactory {
//创建代理对象
public Object createMyCalculate(Object obj){
//Proxy是java反射中的一个类 obj.getClass().getClassLoader()获取类加载器 实现的接口
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), new InvocationHandler() {
@Override
//代理的那个对象（传入的） 要处理的方法 传入的参数
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("star");
//调用方法并执行
Object invoke = method.invoke(obj, args);
System.out.println("end");
return invoke;
}
});
}
}

public class Text {
public static void main(String[] args) {
ProxyFactory proxyFactory=new ProxyFactory();
Calculateimpl calculateimpl=new Calculateimpl();
Calculate calculate=(Calculate)proxyFactory.createMyCalculate(calculateimpl));
calculate.add(1,3);
}
}

/**
* 定义advice
*/
public class Advice {
public void before(){
System.out.println("前");
}
public void mythrow(Exception e){
// 还需要配置xml才可以打印出异常信息
System.out.println("异常"+e.getMessage());
}
public void after(){
System.out.println("后");
}
public void aftering(){
System.out.println("aftering");
}
public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("执行环绕通知");
System.out.println("环绕-前置");
// 返回值
Object proceed = proceedingJoinPoint.proceed();
System.out.println(proceed);
System.out.println("环绕-后置");
return proceed;
}
}

public class Demo {
public int min(int i,int j){
return i+j;
}
}

public class Text {
public static void main(String[] args) { ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
Demo demo = cxt.getBean("demo", Demo.class);
demo.min(1,5);
}
}

<!--将要被增强的对象注入进来-->
<bean class="com.xpl.test.Demo" id="demo"/>
<!--将advice注入进来-->
<bean class="com.xpl.advice.Advice" id="advice"/>
<aop:config>
<!--定义切点：就是要在哪个方法上增强-->
<aop:pointcut id="min" expression="execution(int com.xpl.test.Demo.min(int ,int ))"/>
<!--定义切面：切点+增强--> <!--引用的就是上边注入进来的增强Bean-->
<aop:aspect ref="advice"> <!--这几个增强是有顺序的特别是异常aftering和after-->
<!--通知类型 增强方法名（增强类中的） 被增强的方法（上边定义的切点）--> <!--after和after-returning的区别：-->
<!--after无论是否抛出异常都会执行-->
<!--after-returning必须正确执行才会执行-->
<aop:after method="after" pointcut-ref="min"/>
<aop:after-returning method="aftering" pointcut-ref="min"/>
<aop:after method="before" pointcut-ref="min"/>
<!--必须和增强类中异常方法中参数的异常名相同-->
<aop:after-throwing method="mythrow" pointcut-ref="min" throwing="e"/> <aop:around method="around" pointcut-ref="min"/>
</aop:aspect>
</aop:config>

<aop:pointcut id="min" expression="execution(int com.xpl.test.Demo.min(int ,int ))"/>表示com包下的所有包中的所有方法
<aop:pointcut id="min" expression="execution(* com.*.*.*.*(* ,* ))"/>

public class B {
private String name;
private A a;public class A {
private String name;

没有自动注入
<bean class="com.xpl.model.A" id="a">
<property name="name" value="aaa"/>
</bean>-->
<bean class="com.xpl.model.B" id="b">
<property name="name" value="bbbbb"/>
<property name="A" ref="a"/>
</bean>自动注入
<bean class="com.xpl.model.A" id="a">
<property name="name" value="aaa"/>
</bean>
<bean class="com.xpl.model.B" id="b" autowire="byName">
<property name="name" value="bbbbb"/>
</bean>

<?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"
default-autowire="byName">

db.driver=com.mysql.jdbc.Driver
db.username=root
db.password=root
db.url=jdbc:mysql:///test?useUnicode=true&characterEncoding=UTF-8

<?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:property-placeholder location="classpath:db.properties"/>
<!--配置数据源-->
<bean class="org.springframework.jdbc.datasource.DriverManagerDataSource" id="dataSource">
<property name="driverClassName" value="${db.driver}"/>
<property name="username" value="${db.username}"/>
<property name="password" value="${db.password}"/>
<property name="url" value="${db.url}"/>
</bean>
<!--创建sqlSessionFactory-->
<bean class="org.mybatis.spring.SqlSessionFactoryBean" id="factory">
<!--创建sqlSession需要有数据库连接，na那么就引用上边的数据源-->
<property name="dataSource" ref="dataSource"/>
<property name="typeAliasesPackage" value="com.xpl.model"/>
</bean>
//扫描配置mapper.xml文件
<bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
<property name="dataSource" ref="dataSource"/>
<property name="typeAliasesPackage" value="com.xpl.model"/>
<property name="mapperLocations">
<list>
<value>classpath*:com/xpl/mapper/*.xml</value>
</list>
</property>
</bean>
<!--扫描器，加载mapper接口-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
//配置这一句就可以mapper接口和mapper.xml不写在一个文件夹了
<property name="basePackage" value="com.xpl.mapper"/>
<property name="sqlSessionFactoryBeanName" value="factory"/>
<!--<property name="sqlSessionFactory" ref="factory"/>-->
</bean>
</beans>

people.name=xupeilei

两种方式，将bean交给Spring容器！！！这是关键，要想去spring容器中的全局的值，就一定要把这个Bean交给Spring管理！！！！！
方式一：直接配置进去<bean class="com.xpl.model.People" id="people"/>方式二：通过包扫描
<context:component-scan base-package="com.xpl.model"/>

public class People {
name这个属性名和取值时的name名没有必然关系，可以不一样
@Value("${people.name}")
private String name;

<?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" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
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
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!--配置数据库链接-->
<!--引入数据库连接信息-->
<context:property-placeholder location="classpath:db.properties"/>
<!--配置数据库里连接池-->
<bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
<property name="url" value="${db.url}"/>
<property name="username" value="${db.username}"/>
<property name="password" value="${db.password}"/>
</bean>
<!--配置mybatis-->
<!--配置mapper-->
<bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
<property name="dataSource" ref="dataSource"/>
<property name="typeAliasesPackage" value="com.xpl.model"/>
<property name="mapperLocations">
<list>
<value>classpath*:com/xpl/mapper/*.xml</value>
</list>
</property>
</bean>
<!--自动获取getXXX(mapper.xlass)-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!--获取那个接口 value就是上边配的SqlSessionFactoryBean-->
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
<!--接口所在的文件夹 这里配置完了就不需要将接口和mapper文件放一个文件夹了-->
<property name="basePackage" value="com.xpl.mappering"/>
</bean> <!--配置事务-->
<bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="dataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<tx:advice id="txAdvice" transaction-manager="dataSourceTransactionManager">
<tx:attributes>
<tx:method name="add*"/>
<tx:method name="upd*"/>
<tx:method name="del*"/>
<tx:method name="sel*"/>
<tx:method name="*" read-only="true"/>
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut id="pc1" expression="execution(* com.xpl.service.*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="pc1"/>
</aop:config>
</beans>

<tx:method name="add*" read-only="" propagation=""/>

<tx:method name="add*" isolation="DEFAULT"/>

<tx:method name="add*"rollback-for="" no-rollback-for=""/>