第一个spring程序

最新推荐文章于 2024-09-02 17:10:10 发布
最新推荐文章于 2024-09-02 17:10:10 发布
阅读量113 收藏
点赞数
文章标签： optimization spring javabean ioc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/curry123456/article/details/109390728
版权

6.1.spring中pom.xml的配置

spring官方文档在这个链接https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.6.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.12</version>
        <scope>provided</scope>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
        <scope>test</scope>
    </dependency>

</dependencies>

<repositories>
    <repository>
        <id>alimaven</id>
        <name>aliyun maven</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        <releases>
            <enabled>true</enabled>
        </releases>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </repository>
</repositories>

2.beans.xml配置文件：

<?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-3.0.xsd">

    <bean id="hello" class="com.kuang.pojo.User">
        <property name="name" value="Spring"/>
    </bean>
    </beans>
//id:相当于变量名
//class 相当于new 类（）
</beans>

3.SpringTest测试代码：

public void Test(){
    ApplicationContext context =
            new ClassPathXmlApplicationContext("Beans.xml");
    User name= (User) context.getBean("hello");
    System.out.println(name.toString());



}

4.ioc创建对象的方式

1.使用无参构造创建对象

<bean id="construct" class="com.kuang.yb.construct">
</bean>

2.加入要使用有参构造

bean.xml:
<bean id="construct1" class="com.kuang.yb.construct">
    <constructor-arg name="id" value="1"></constructor-arg>
    <constructor-arg name="name" value="yx"></constructor-arg>
</bean>

3.set注入

<bean id="name" class="com.kuang.pojo.student">
    <property name="name" value="杨欣小胖胖"></property>//value赋值
    <property name="address" ref="adress"></property>//ref引用赋值
    <property name="books">//数组赋值
        <array>
            <value>库里</value>
            <value>汤普森</value>
            <value>格林</value>
        </array>
    </property>
    
    <property name="hobbys" >list集合赋值
        <list>
            <value>打篮球</value>
            <value>踢足球</value>
        </list>
    </property>
    <property name="card" >//map集合赋值
        <map>
            <entry key="中国邮政银行" value="142155376417"/>
            <entry key="中国建设银行" value="2165327846328"/>
        </map>
    </property>
    //set注入
    <property name="games">
        <set>
            <value>2k</value>
        </set>
    </property>
</bean>

</beans>

4.p命名空间，c命名空间

1.p命名空间

加入约束： xmlns:p=“http://www.springframework.org/schema/p”

bean.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       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-3.0.xsd">
    <!--p命名空间直接注入属性-->
    <bean id="namespace" class="com.kuang.namespace.Student" p:grade="100" p:id="1" p:name="易彪"></bean>
    <!--c命名空间通过构造器注入-->
    <bean id="namespace1" class="com.kuang.namespace.Student"  c:name="杨欣" c:id="2"></bean>

</beans>

2.c命名空间

加入约束： xmlns:c=“http://www.springframework.org/schema/c”

bean.xml:

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       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-3.0.xsd">
    <!--p命名空间直接注入属性-->
    <bean id="namespace" class="com.kuang.namespace.Student" p:grade="100" p:id="1" p:name="易彪"></bean>
    <!--c命名空间通过构造器注入-->
    <bean id="namespace1" class="com.kuang.namespace.Student"  c:name="杨欣" c:id="2"></bean>

</beans>

5.bean的作用域：

1.单例模式：每次去容器中get时都是拿到原来的对象 加入scope="singleton"即为单例模式

<bean id="namespace" class="com.kuang.namespace.Student" p:grade="100" p:id="1" p:name="易彪" scope="singleton"></bean>

2.原型模式：每次去容器中get时都是拿到不同的对象 加入scope="prototype"即为原型模式

<bean id="namespace1" class="com.kuang.namespace.Student"  c:name="杨欣" c:id="2" scope="prototype"></bean>

6.自动装配

1.beans.xml

<?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-3.0.xsd">
    <bean id="dog" class="com.baidu.pojo.Dog"></bean>
    <bean id="cat" class="com.baidu.pojo.Cat"></bean>
    <!--
    byName:找与set方法后面名字相同的bean id;
    byType:找到与自己对象属性类型相同的bena id;
    -->
    <bean id="people" class="com.baidu.pojo.People" autowire="byName">
        <property name="name" value="杨欣"></property>

    </bean>
</beans>

2.实体类

package com.baidu.pojo;                    


public class People {
    String name;
    Dog dog;
    Cat cat;


    public String getName() {
        return name;
    }

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

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }
}
//
package com.baidu.pojo;

public class Dog{
    public Dog(){

    }
    public void shou(){
        System.out.println("汪汪汪");
    }
}

///
package com.baidu.pojo;

public class Cat {

        public Cat(){

        }
        public void shou(){
            System.out.println("喵喵喵");
        }
    }

7.使用注解自动装配

1.导入注解约束

<?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:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 开启注解支持 -->
    <context:annotation-config/>

    <bean id="cat" class="com.baidu.pojo.Cat" />
    <bean id="dog" class="com.baidu.pojo.Dog" />
    <bean id="people" class="com.baidu.pojo.People" />
</beans>

2.配置注解支持 context:annotation-config/

3.实体类

package com.baidu.pojo;


import org.springframework.beans.factory.annotation.Autowired;


public class People {

    String name;
    @Autowired//自动装配属性
    
    Dog dog;
    @Autowired
     @Qualifier("cat111")//识别是那个bean的id
    Cat cat;


    public String getName() {
        return name;
    }

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

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }
}

总结 @Autowired：直接通过byType查找，加入 @Qualifier(“cat111”)通过byName查找

​ @Resource：先通过byName查找，如果找不到，在通过byType查找

8.Spring注解开发

@Component
    <!--自动扫描com.baidu,pojo下面的包-->
    <context:component-scan base-package="com.baidu.pojo"/>
    //配套使用，在类上加入Component 说明可以被自动扫描到

@Repository//仓库类dao层
@@Controller//controller层
@Service//service层

9.javaConfig实现配置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WbvukqGm-1604053553040)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20201015165916133.png)]

test代码

public void test02(){
    ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
    Student student = context.getBean("getStudent",Student.class);
    System.out.println(student.id);
}

10.静态代理模式

源码：

package com.kuang.demo01;

public class UserServiceImpl implements UserService{

    public void add() {

        System.out.println("增加方法");
    }

    public void delete() {
        System.out.println("删除方法");
    }

    public void insert(){
        System.out.println("插入方法");
    }

    public void update(){
        System.out.println("更新方法");
    }

}

/
package com.kuang.demo01;

public class UserServiceProxy implements UserService {
private UserService uservice;

public void setUservice(UserService uservice){
    this.uservice=uservice;
}
    public void add() {
        System.out.println("测试代理模式");
     uservice.add();
    }

    public void delete() {

    }

    public void insert() {

    }

    public void update() {

    }
}
///
  public static void main(String[] args) {
        /*userService.update();
        userService.delete();
        userService.add();*/

        UserService userService=new UserServiceImpl();
        UserServiceProxy proxy=new UserServiceProxy();
        proxy.setUservice(userService);
        proxy.add();//通过代理实现add（）方法
    }

11.动态代理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3OuZyUYf-1604053553042)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20201015195547967.png)]

代码实现：（代理的是接口）

package com.kuang.demo;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

//代理类实现InvocationHandler接口，重写方法
public class Proxy implements InvocationHandler {

//被代理的对象
    private Rent rent;
    public void setRent(Rent rent) {
        this.rent = rent;
    }

    //生成代理类的方法
    public Object getProxy(){
        /*
        第一个参数获得类加载器
        第二个参数被代理的对象的接口
        第三个参数 InvocationHandler
        * */
        return java.lang.reflect.Proxy.
                newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);

    }

    //处理代理实例，并得到返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

       return method.invoke(rent,args);
    }
}

///
package com.kuang.demo;



public class Client {
    public static void main(String[] args) {
        //真实角色
        Host host =new Host();
        //通过调用程序处理角色来处理我们要调用的接口
       Proxy in=new Proxy();
        in.setRent(host);
        //得到代理对象
        Rent proxy = (Rent) in.getProxy();
        proxy.rent();
    }
}

动态代理utils:

package com.kuang.utils;



import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class utilsProxy implements InvocationHandler {

    //要调用的接口对象
    private Object target;
    public void setTarget(Object target){
        this.target=target;
    }
    //生成代理类的方法
    public Object getUserServiceProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }



    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return method.invoke(target,args);
    }
}

12.AOP

1.使用原生spring接口实现

1.测试代码

public class MyTest {
    @Test
    public void test01(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserService uservice= (UserService) context.getBean("UserService");
        uservice.delete();
        
        
        ///
        com.baidu.service.UserServiceImpl的delete调用删除方法
        com.baidu.service.UserServiceImpl执行了delete返回结果为null

    }

2.beans.xml


<!-- 开启注解支持 -->
    <context:annotation-config/>
    <context:component-scan base-package="com.baidu.log"/>
    <context:component-scan base-package="com.baidu.service"/>
<bean id="UserService" class="com.baidu.service.UserServiceImpl"/>
    <aop:config>
        <!--
         1、execution(): 表达式主体。

 2、第一个*号：表示返回类型，*号表示所有的类型。

 3、包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.sample.service.impl包、子孙包下所有类的方法。

 4、第二个*号：表示类名，*号表示所有的类。

 5、*(..):最后这个星号表示方法名，*号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数。
        -->
        <aop:pointcut id="pointcut" expression="execution(* com.baidu.service.*.*(..))"/>
        <!--执行环绕-->advice-ref通知
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

2.使用自定义接口实现

1.bean.xml

<!--aop方式二自定义类实现-->
<aop:config>
    <!--自定义切面要引用的类-->
    <aop:aspect ref="log">
        <!--切入点-->
        <aop:pointcut id="point" expression="execution(* com.baidu.service.*.*(..))"/>
        <!--通知-->
        <aop:before method="beforeLog" pointcut-ref="point"></aop:before>
        <aop:after method="afterLog" pointcut-ref="point"></aop:after>
    </aop:aspect>
</aop:config>

2.测试代码

public class MyTest {
    @Test
    public void test01(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserService uservice= (UserService) context.getBean("UserService");
        uservice.delete();

    }
    }

13.Spring-Mybatis整合方式一

1.bookMapperImpl类

package com.baidu.mapper;

import com.baidu.pojo.books;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.SqlSessionTemplate;

import java.util.List;

public class bookMapperImpl implements bookMapper {

    private SqlSessionTemplate sqlsession;

    public void setSqlsession(SqlSessionTemplate sqlsession) {
        this.sqlsession = sqlsession;
    }

    public List<books> select() {
        bookMapper mapper = sqlsession.getMapper(bookMapper.class);
        return mapper.select();
    }
}

2.pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>SpringMybtis01</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>SpringMybatis02</module>
    </modules>

    <dependencies>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.19</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.4.6</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.12</version>
        <scope>provided</scope>
    </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.5</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.9.RELEASE</version>
        </dependency>

    </dependencies>

    <build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

</project>

3.Spring-Mybatis.xml

<?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:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 开启注解支持 -->
    <context:annotation-config/>
    <!--数据库连接注入-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property  name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/user?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false&amp;serverTimezone = GMT"/>
        <property name="username" value="root"/>
        <property name="password" value="123"/>
    </bean>
    <!--生成sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="configLocation" value="classpath:MybatisConfig.xml"></property>
    </bean>
     <!--生成sqlsession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory"/>
     </bean>
   
    <bean id="bookServiceImpl" class="com.baidu.mapper.bookMapperImpl">
        <property name="sqlsession" ref="sqlSession"/>
    </bean>

</beans>

2.方式二SqlSessionDaoSupport

SqlSessionDaoSupport 是一个抽象的支持类，用来为你提供 SqlSession。调用 getSqlSession() 方法你会得到一个 SqlSessionTemplate，之后可以用于执行 SQL 方法，就像下面这样:

public class UserDaoImpl extends SqlSessionDaoSupport implements UserDao {
  public User getUser(String userId) {
    return getSqlSession().selectOne("org.mybatis.spring.sample.mapper.UserMapper.getUser", userId);
  }
}

在这个类里面，通常更倾向于使用 MapperFactoryBean，因为它不需要额外的代码。但是，如果你需要在 DAO 中做其它非 MyBatis 的工作或需要一个非抽象的实现类，那么这个类就很有用了。

SqlSessionDaoSupport 需要通过属性设置一个 sqlSessionFactory 或 SqlSessionTemplate。如果两个属性都被设置了，那么 SqlSessionFactory 将被忽略。

假设类 UserMapperImpl 是 SqlSessionDaoSupport 的子类，可以编写如下的 Spring 配置来执行设置：

<bean id="userDao" class="org.mybatis.spring.sample.dao.UserDaoImpl">
  <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

14.事务

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eXrrL7tk-1604053553045)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20201017215851987.png)]

配置事务

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iSPib7ax-1604053553048)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20201017225603809.png)]

<!--要开启 Spring 的事务处理功能，在 Spring 的配置文件中创建一个 DataSourceTransactionManager 对象：-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <constructor-arg ref="dataSource" />
</bean>
<!--配置事务传播特性-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>
<!--配置事务切入-->
<aop:config>
    <aop:pointcut id="txpoint" expression="execution(* com.baidu.mapper.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txpoint"/>
</aop:config>
```
curry123456
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
第一个Spring程序
洛卡JAVA架构师每日分享Java架构师知识
05-16 153
本节介绍如何使用 Eclipse IDE 创建一个简单的 Spring 程序。在编写之前，我们必须确保已经正确搭建了 Spring 开发环境，不了解的读者请转到：Spring开发环境搭建 1. 创建 Java 项目 在 Eclipse 中创建一个简单的 Java 项目，依次单击 File -> New -> Java Project，这里将项目名称设置为 HelloSpring。 图1：创建 Java 项目 2. 添加 jar 包 这里我们需要在项目中添加 Spring 和 logg
Spring入门---第一个spring程序
文天哥哥的博客
04-16 1043
一、准备spring开发的基础包 下载地址：http://repo.spring.io/simple/libs-release-local/org/springframework/spring/4.3.6.RELEASE/ 在使用Spring开发时，除了要使用自带的JAR包外，Spring的核心容器还需要依赖commons.logging的JAR包。 下载地址：http://com...
【Spring框架全系列】第一个Spring程序
冲击大厂之路!!!
05-02 1962
第一个Spring程序，如何配置spring项目，如何添加启动类，如何存取对象；
Spring Boot |使用IDEA搭建第一个Spring Boot程序
匿名攻城狮
03-21 2279
文章目录环境准备第一步:创建一个Maven程序第二步:导入SpringBoot相关依赖第三步:编写主程序第四步:编写Controller第五步:将程序跑起来第六步:简化部署 第一个Spring Boot实现的功能： 浏览器发送hello请求，服务器接收请求并处理，响应"HelloWorld!"字符串。 环境准备 工具 版本 JDK 1.8 Apache Maven 3....
编写第一个Spring程序——IOC实现
栗筝i的博客
09-23 3063
第一个Spring程序 IOC范例 1、新建maven工程 2、在pom.xml文件中导入相关jar包 <!-- https://mvnrepository.com/artifact/org.springframework/spring-core --> <dependency> <groupId>org.springframework</groupId> <artifact
Spring2.0（一）第一个Spring程序、IoC的应用
03-21
首先，让我们来看看如何创建第一个Spring程序。 1. **环境准备**：你需要安装JDK 5或更高版本，然后配置好Java环境变量。同时，确保你的项目构建工具（如Maven或Gradle）中包含了Spring的相关依赖。 2. **创建Bean...
编写第一个Spring程序（XML方法+注解方法）
BAI20010904的博客
01-14 767
目录 一、Spring开发环境 二、编写第一个Spring程序 1.编写pom.xml文件，导入相关依赖 2. 新建实体类 3.在resource目录下，创建beans.xml文件 4.创建测试类 三、注解开发 1.编写pom.xml文件，导入相关依赖 2. 新建实体类 3.在resource目录下新建beans.xml文件 4.编写测试类 一、Spring开发环境 推荐网站 Maven资源搜索页面：https://mvnrepository.com/ Spr...
编写第一个 Spring MVC 程序
08-14
在本教程中，我们将详细讲解如何编写第一个 Spring MVC 程序，涵盖其核心概念、配置以及实现过程。 1. **Spring MVC 概述** Spring MVC 为 Web 开发提供了模型-视图-控制器（MVC）架构模式，它简化了业务逻辑与...
我的第一个Spring程序
04-08
我的第一个Spring程序 Environment: [1]JDK 1.7.x [2]Eclipse-jee-mars-2-win32 [3]Tomcat7 [4]Spring 3.1.0 [5]Maven 3.3.9
高级java每日一道面试题-2024年8月28日-框架篇[Spring篇]-Spring 框架是什么?
qq_43071699的博客
08-28 800
1. 定义与起源Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。它由Rod Johnson最早提出，目的是解决企业级应用开发的复杂性，简化Java开发。2. 核心特性控制反转（IoC）：也称为依赖注入（DI），是Spring框架的核心。它将对象的创建和依赖关系的管理交给了容器，降低了代码间的耦合度。面向切面编程（AOP）：Spring提供了丰富的AOP支持，允许开发者将横切关注点（如日志、事务管理等）从业务逻辑中分离出来，形成可重用的功能组件。
SpringBoot项目初始化搭建
weixin_63405049的博客
08-30 1756
本章主要讲解了SpringBoot项目初始化搭建，编程事务的使用，分页依赖的使用，以及跨域问题如何解决，解决了轻量级项目构建初期遇到的一些问题，提供于前后端交互时产生的问题进行分析与解决
Spring Security 认证源码超详细分析
緑水長流*z
08-30 745
AbstractAuthenticationProcessingFilter 为处理认证请求提供了一个基础框架。这个抽象类主要用于处理 HTTP 请求，并将其转换为 Authentication 对象，然后提交给 AuthenticationManager 进行认证。这不就是我们前面介绍的 UsernamePasswordAuthenticationFilter 吗？
Spring理论知识（Ⅳ）——Spring Instrumentation模块
最新发布
敢问路在何方，路在脚下
09-02 497
总的来说，Spring Instrumentation提供了类植入（Instrumentation）支持和类加载器的实现，可以在特定的应用服务器中使用。本质上是一种JVM级别（操作系统级别）的AOP，用到了代理java.lang.instrument（容器类）做动态Instrumentation是Java SE 5的新特性使用 Instrumentation，开发者可以构建一个独立于应用程序的代理程序（Agent），用来监测和协助运行在 JVM 上的程序，甚至能够替换和修改某些类的定义。
自己开发完整项目一、登录功能-03(使用springSecurity安全框架,查询用户角色权限)
qq_40072583的博客
08-31 728
在前面两章节，实现了通过springsecurity来进行用的登录认证，当用户输入用户名和密码之后，通过额数据库中的信息比对，比对成功那么放行。但是还存在一个问题：因为系统的所有页面包括按钮都是有各自的权限，那么要想实现不同的用户登录成功看到的页面不同并且有不同的操作范围，那么就需要对用户的权限进行验证。实现的思路:在用户登录的时候，将用户的权限查询出来。
spring security 会话管理
冬阳
08-31 1193
当浏览器调用登录接口登录成功后，服务端会和浏览器之间建立一个会话(Session)浏览器在每次发送请求时都会携带一个 Sessionld，服务端则根据这个 Sessionld 来判断用户身份当浏览器关闭后，服务端的 Session 并不会自动销毁，需要开发者手动在服务端调用Session销毁方法，或者等 Session 过期时间到了自动销毁。
Spring Security 用户认证和授权管理
weixin_44876263的博客
09-02 850
文章目录一、介绍1、简介2、核心概念3、主要功能4、处理流程二、Spring Security实现权限1、添加依赖2、执行顺序和代码执行流程（1）用户登录（2）访问受保护资源总结1、用户登录2、访问受保护资源完整源码 一、介绍 1、简介 Spring Security 是一个强大的安全框架，旨在保护基于 Spring 的应用程序。它提供了一整套全面的安全功能，包括认证、授权、以及防护常见安全攻击的机制。 2、核心概念 认证（Authentication） 认证是验证用户身份的过程。在 Spring S
Spring TransactionTemplate 深入解析与高级用法
DS_Watson的博客
09-02 590
TransactionTemplate` 是 Spring 框架中一个强大的工具，它允许开发者以编程方式控制事务。通过本文的详细解析和示例代码，我们可以看到如何使用 `TransactionTemplate` 来执行事务性操作，并处理高级事务场景。在实际开发中，合理使用事务管理对于确保数据一致性和系统稳定性至关重要。
解决Spring的代理失效问题
初心不忘、始终方得
08-28 247
解决Spring的代理失效问题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值